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') 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(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')
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()
old_file = os.path.join(old_folder, file) new_file = os.path.join(new_folder, file) if self.MIGRATETYPE == 'move': xbmcvfs.copy( old_file, new_file ) xbmcvfs.delete( old_file ) elif self.MIGRATETYPE == 'copy': xbmcvfs.copy( old_file, new_file ) else: test_str = test_str + old_file + ' to ' + new_file + '\n' if self.MIGRATETYPE == 'move': xbmcvfs.rmdir ( old_folder ) count += 1 if self.MIGRATETYPE == 'test': success, loglines = writeFile( test_str, os.path.join( self.MIGRATEFOLDER, '_migrationtest.txt' ) ) lw.log( loglines ) pDialog.close() def _remove_trailing_dot( self, thename ): if thename[-1] == '.' and len( thename ) > 1 and self.ENDREPLACE <> '.': return self._remove_trailing_dot( thename[:-1] + self.ENDREPLACE ) else: return thename if ( __name__ == "__main__" ): lw.log( ['script version %s started' % addonversion], xbmc.LOGNOTICE ) lw.log( ['debug logging set to %s' % logdebug], xbmc.LOGNOTICE ) Main() command = 'XBMC.Notification(%s, %s, %s, %s)' % (smartUTF8(language(30330)), smartUTF8(language(30331)), 3000, smartUTF8(addonicon)) xbmc.executebuiltin( command )
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)