def __init__(self, providers, method, timeout=10):
     super(ProviderListenerDialog, self).__init__(providers,
                                                  method,
                                                  timeout=timeout)
     self._total = len(providers)
     self._count = 0
     self._dialog = DialogProgressBG()
 def show_progress_background(heading='', message=''):
     """ Show a Kodi progress dialog """
     from xbmcgui import DialogProgressBG
     if not heading:
         heading = ADDON.getAddonInfo('name')
     progress = DialogProgressBG()
     progress.create(heading=heading, message=message)
     return progress
 def _get_artists_hashmap( self ):
     #gets a list of all the artists from XBMC
     pDialog = DialogProgressBG()
     pDialog.create( smartUTF8(language(32001)), smartUTF8(language(30301)) )
     hashmap = _ordereddict()
     response = xbmc.executeJSONRPC ( '{"jsonrpc":"2.0", "method":"AudioLibrary.GetArtists", "params":{"albumartistsonly":false, "sort":{"order":"ascending", "ignorearticle":true, "method":"artist"}},"id": 1}}' )
     try:
         artists_info = _json.loads(response)['result']['artists']
     except (IndexError, KeyError, ValueError):
         artists_info = []
     except Exception, e:
         lw.log( ['unexpected error getting JSON back from XBMC', e] )
         artists_info = []
Exemple #4
0
    def __run(self):
        """
        Do the work
        """
        log.debug('Show sync info thread started')
        # cache local variables because it's faster
        total = self.total
        dialog = DialogProgressBG('dialoglogProgressBG')
        thread_stopped = self.thread_stopped
        dialog.create("%s %s: %s %s" %
                      (lang(39714), self.item_type, str(total), lang(39715)))
        player = Player()

        total = 2 * total
        totalProgress = 0
        while thread_stopped() is False and not player.isPlaying():
            with LOCK:
                get_progress = GET_METADATA_COUNT
                process_progress = PROCESS_METADATA_COUNT
                viewName = PROCESSING_VIEW_NAME
            totalProgress = get_progress + process_progress
            try:
                percentage = int(float(totalProgress) / float(total) * 100.0)
            except ZeroDivisionError:
                percentage = 0
            dialog.update(percentage,
                          message="%s %s. %s %s: %s" %
                          (get_progress, lang(39712), process_progress,
                           lang(39713), viewName))
            # Sleep for x milliseconds
            sleep(200)
        dialog.close()
        log.debug('Show sync info thread terminated')
 def _run_server(self, host, port):
     app.frame_data = self._frame_data
     httpd = make_server(host, port, app, ws_handler_class=WebConsoleSocket)
     logger.info('Web-PDB: starting web-server on {0}:{1}...'.format(
             httpd.server_name, port)
     )
     dialog = DialogProgressBG()
     started = False
     while not (self._stop_all.is_set() or kodi_monitor.abortRequested()):
         try:
             httpd.handle_request()
         except SystemExit:
             break
         if not started:
             logger.info('Web-PDB: web-server started.')
             dialog.create(
                 addon.getLocalizedString(32001),
                 addon.getLocalizedString(32002).format(
                     httpd.server_name, port
                 )
             )
             dialog.update(100)
             started = True
     httpd.handle_close()
     logger.info('Web-PDB: web-server stopped.')
     dialog.close()
    def run(self):
        """
        Do the work
        """
        LOG.debug('Show sync info thread started')
        # cache local variables because it's faster
        total = self.total
        dialog = DialogProgressBG('dialoglogProgressBG')
        dialog.create("%s %s: %s %s" % (utils.lang(39714), self.item_type,
                                        unicode(total), utils.lang(39715)))

        total = 2 * total
        total_progress = 0
        while not self.stopped():
            with LOCK:
                get_progress = GET_METADATA_COUNT
                process_progress = PROCESS_METADATA_COUNT
                view_name = PROCESSING_VIEW_NAME
            total_progress = get_progress + process_progress
            try:
                percentage = int(float(total_progress) / float(total) * 100.0)
            except ZeroDivisionError:
                percentage = 0
            dialog.update(percentage,
                          message="%s %s. %s %s: %s" %
                          (get_progress, utils.lang(39712), process_progress,
                           utils.lang(39713), view_name))
            # Sleep for x milliseconds
            sleep(200)
        dialog.close()
        LOG.debug('Show sync info thread terminated')
Exemple #7
0
 def __init__(self, host, port, patch_stdstreams=False):
     cry('listen socket')
     self._listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self._listen_socket.settimeout(None)
     cry('setsokcport')
     self._listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
     cry('bind')
     self._listen_socket.bind((host, port))
     self._stop_monitor = threading.Event()
     self._monitor_thread = threading.Thread(target=self._monitor_abort)
     self._monitor_thread.daemon = True
     self._monitor_thread.start()
     if not host:
         host = socket.gethostname()
     port = self._listen_socket.getsockname()[1]
     cry("RemotePdb session open at %s:%s, waiting for connection ..." % (host, port))
     self._dialog = DialogProgressBG()
     self._dialog.create('remote-pdb',
                         'Waiting for connection at [COLOR=yellow]%s:%s[/COLOR]' % (host, port)
                         )
     self._listen_socket.listen(1)
     self._connection, address = self._listen_socket.accept()
     self._connection.settimeout(None)
     self._dialog.update(100, heading='remote-pdb', message='Connection from %s active' % address[0])
     cry("RemotePdb accepted connection from %s." % repr(address))
     if PY3:
         self.handle = LF2CRLF_FileWrapper(self._connection.makefile('rw'))
     else:
         self.handle = LF2CRLF_FileWrapper(self._connection.makefile())
     Pdb.__init__(self, completekey='tab', stdin=self.handle, stdout=self.handle)
     self.backup = []
     if patch_stdstreams:
         for name in (
                 'stderr',
                 'stdout',
                 '__stderr__',
                 '__stdout__',
                 'stdin',
                 '__stdin__',
         ):
             self.backup.append((name, getattr(sys, name)))
             setattr(sys, name, self.handle)
     RemotePdb.active_instance = self
def update_tvdb():
    progress_bar = DialogProgressBG()
    progress_bar.create(heading="Downloading database...")
    msg = "Базата данни НЕ бе обновена!"
    try:
        log('Force-updating tvdb')
        # recreated the db_file in case db_file is overwritten by use_local_db
        __db_file__ = os.path.join(get_resources_dir(), 'tv.db')
        asset = Assets(__db_file__, backup_db_file)
        progress_bar.update(1, "Downloading database...")

        errors = asset.update(settings.url_db)
        if errors:
            notify_error(msg + "\n" + errors)

        if settings.use_local_db:
            notify_success("Използвате локална база данни!")

    except Exception as ex:
        log(ex, 4)

    if progress_bar:
        progress_bar.close()
class ProviderListenerDialog(ProviderListener):
    def __init__(self, providers, method, timeout=10):
        super(ProviderListenerDialog, self).__init__(providers,
                                                     method,
                                                     timeout=timeout)
        self._total = len(providers)
        self._count = 0
        self._dialog = DialogProgressBG()

    def on_receive(self, sender):
        self._count += 1
        self._dialog.update(int(100 * self._count / self._total))

    def __enter__(self):
        ret = super(ProviderListenerDialog, self).__enter__()
        self._dialog.create(ADDON_NAME, translate(30111))
        return ret

    def __exit__(self, exc_type, exc_val, exc_tb):
        try:
            return super(ProviderListenerDialog,
                         self).__exit__(exc_type, exc_val, exc_tb)
        finally:
            self._dialog.close()
Exemple #10
0
def bg_progress_dialog():
    """Show Kodi's Background Progress dialog"""
    return DialogProgressBG()
def generate_playlist():
    '''
  Function executed by scheduler to generate a playlist
  '''
    progress_bar = DialogProgressBG()
    debug = settings.debug
    is_manual_run = False if len(
        sys.argv) > 1 and sys.argv[1] == 'False' else True

    if not is_manual_run:
        log('Автоматично генериране на плейлиста')

    if debug or is_manual_run:
        progress_bar.create(heading=get_addon_name())

    def show_progress(percent, msg):
        if debug or is_manual_run:
            heading = "%s %s%%" % (get_addon_name().encode('utf-8'),
                                   str(percent))
            progress_bar.update(percent, heading, msg)
            log(msg)

    try:
        if not settings.use_local_db:
            asset = Assets(db_file, backup_db_file)
            if asset.is_old():
                errors = asset.update(settings.url_db)
                if errors:
                    notify_error('Базата данни не бе обновена! %s' % errors)

        show_progress(10, 'Зареждане на канали от базата данни %s ' % db_file)

        conn = sqlite3.connect(db_file)
        cursor = conn.execute(
            '''SELECT c.id, c.disabled, c.name, cat.name AS category, c.logo, 
        COUNT(s.id) AS streams, s.stream_url, s.page_url, s.player_url, c.epg_id, u.string, c.ordering 
      FROM channels AS c 
      JOIN streams AS s ON c.id = s.channel_id 
      JOIN categories as cat ON c.category_id = cat.id
      JOIN user_agents as u ON u.id = s.user_agent_id
      WHERE c.disabled <> 1
      GROUP BY c.name, c.id
      ORDER BY c.ordering''')

        show_progress(20, 'Генериране на плейлиста')
        update('generation', 'PlaylistGenerator')

        pl = Playlist(settings.include_radios)
        show_progress(25, 'Търсене на потоци')
        n = 26

        for row in cursor:
            try:
                c = Channel(row)
                n += 1
                show_progress(n, 'Търсене на поток за канал %s' % c.name)

                cursor = conn.execute('''SELECT s.*, u.string AS user_agent 
          FROM streams AS s 
          JOIN user_agents as u ON s.user_agent_id == u.id 
          WHERE disabled <> 1 AND channel_id = %s AND preferred = 1''' % c.id)
                s = Stream(cursor.fetchone())

                c.playpath = s.url
                if c.playpath is None:
                    xbmc.log('Не е намерен валиден поток за канал %s ' %
                             c.name)
                else:
                    pl.channels.append(c)

            except Exception, er:
                xbmc.log('Грешка при търсене на поток за канал %s ' % c.name)
                log_last_exception()

        show_progress(90, 'Записване на плейлиста')
        pl.save(get_profile_dir())

        ###################################################
        ### Apend/Prepend another playlist if specified
        ###################################################
        apf = settings.additional_playlist_file
        # if settings.concat_playlist and os.path.isfile(apf):
        # show_progress(92,'Обединяване с плейлиста %s' % apf)
        # pl.concat(apf, settings.append == '1')
        # pl.save(get_profile_dir())

        ###################################################
        ### Copy playlist to additional folder if specified
        ###################################################
        ctf = settings.copy_to_folder
        if settings.copy_playlist and os.path.isdir(ctf):
            show_progress(95, 'Копиране на плейлиста')
            pl.save(ctf)

        ####################################################
        ### Set next run
        ####################################################
        show_progress(98, 'Генерирането на плейлистата завърши!')
        roi = int(settings.run_on_interval) * 60
        show_progress(
            99,
            'Настройване на AlarmClock. Следващото изпълнение на скрипта ще бъде след %s часа'
            % (roi / 60))
        command = "plugin://%s/?action=generate_playlist" % get_addon_id()
        xbmc.executebuiltin(
            'AlarmClock(%s, RunScript(%s, False), %s, silent)' %
            (get_addon_id(), command, roi))
Exemple #12
0
 def __init__(self, database, cursor, progress_bar=True):
     self.epg_db = EpgDb(database, cursor)
     self.progress_bar = DialogProgress(
     ) if progress_bar else DialogProgressBG()
Exemple #13
0
            lw.log( loglines )


    def _migrate( self ):
        lw.log( ['attempting to %s images from Artist Slideshow cache directory' % self.MIGRATETYPE] )
        test_str = ''
        hashmap = self._get_artists_hashmap()
        try:
            folders, throwaway = xbmcvfs.listdir( self.ASCACHEFOLDER )
        except OSError:
            lw.log( ['no directory found: ' + self.ASCACHEFOLDER] )
            return
        except Exception, e:
            lw.log( ['unexpected error while getting directory list', e] )
            return
        pDialog = DialogProgressBG()
        pDialog.create( smartUTF8(language(32003)), smartUTF8(language(30301)) )
        total = len( folders )
        count = 1
        for folder in folders:
            try:
                artist_start = hashmap[folder]
            except KeyError:
                lw.log( ['no matching artist folder for: ' + folder] )
                artist_start = ''
            except Exception, e:
                lw.log( ['unexpected error while finding matching artist for ' + folder, e] )
                artist_start = ''
            if artist_start:
                pDialog.update(int(100*(count/total)), smartUTF8( language(32003) ), smartUTF8( artist_start ) )
                if self.ENABLEFUZZYSEARCH == 'true':
Exemple #14
0
class RemotePdb(Pdb):
    """
    This will run pdb as a ephemeral telnet service. Once you connect no one
    else can connect. On construction this object will block execution till a
    client has connected.

    Based on https://github.com/tamentis/rpdb I think ...

    To use this::

        RemotePdb(host='0.0.0.0', port=4444).set_trace()

    Then run: telnet 127.0.0.1 4444
    """
    active_instance = None
    has_quit = False

    def __init__(self, host, port, patch_stdstreams=False):
        cry('listen socket')
        self._listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self._listen_socket.settimeout(None)
        cry('setsokcport')
        self._listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)
        cry('bind')
        self._listen_socket.bind((host, port))
        self._stop_monitor = threading.Event()
        self._monitor_thread = threading.Thread(target=self._monitor_abort)
        self._monitor_thread.daemon = True
        self._monitor_thread.start()
        if not host:
            host = socket.gethostname()
        port = self._listen_socket.getsockname()[1]
        cry("RemotePdb session open at %s:%s, waiting for connection ..." % (host, port))
        self._dialog = DialogProgressBG()
        self._dialog.create('remote-pdb',
                            'Waiting for connection at [COLOR=yellow]%s:%s[/COLOR]' % (host, port)
                            )
        self._listen_socket.listen(1)
        self._connection, address = self._listen_socket.accept()
        self._connection.settimeout(None)
        self._dialog.update(100, heading='remote-pdb', message='Connection from %s active' % address[0])
        cry("RemotePdb accepted connection from %s." % repr(address))
        if PY3:
            self.handle = LF2CRLF_FileWrapper(self._connection.makefile('rw'))
        else:
            self.handle = LF2CRLF_FileWrapper(self._connection.makefile())
        Pdb.__init__(self, completekey='tab', stdin=self.handle, stdout=self.handle)
        self.backup = []
        if patch_stdstreams:
            for name in (
                    'stderr',
                    'stdout',
                    '__stderr__',
                    '__stdout__',
                    'stdin',
                    '__stdin__',
            ):
                self.backup.append((name, getattr(sys, name)))
                setattr(sys, name, self.handle)
        RemotePdb.active_instance = self

    def _monitor_abort(self):
        while not (xbmc.abortRequested or self._stop_monitor.is_set()):
            time.sleep(0.1)
        if not self._stop_monitor.is_set():
            self.do_quit(None)

    def __restore(self):
        if self.backup:
            cry('Restoring streams: %s ...' % self.backup)
        for name, fh in self.backup:
            setattr(sys, name, fh)
        self.handle.close()
        RemotePdb.active_instance = None

    def do_quit(self, arg):
        self._dialog.close()
        self._stop_monitor.set()
        try:
            self._connection.shutdown(socket.SHUT_WR)
            self._connection.close()
        except AttributeError:
            pass
        self._listen_socket.close()
        try:
            self.__restore()
        except AttributeError:
            pass
        self.set_quit()
        RemotePdb.has_quit = True
        return 1

    do_q = do_exit = do_quit

    def set_trace(self, frame=None):
        if frame is None:
            frame = sys._getframe().f_back
        try:
            Pdb.set_trace(self, frame)
        except IOError as exc:
            if exc.errno != errno.ECONNRESET:
                raise

    def set_quit(self):
        sys.settrace(None)