def qt_schedule(): import signal import sys from apscheduler.schedulers.qt import QtScheduler try: from PyQt5.QtWidgets import QApplication, QLabel except ImportError: try: from PyQt4.QtGui import QApplication, QLabel except ImportError: from PySide.QtGui import QApplication, QLabel def tick(): label.setText('Tick! The time is: %s' % datetime.now()) app = QApplication(sys.argv) # This enables processing of Ctrl+C keypresses signal.signal(signal.SIGINT, lambda *args: QApplication.quit()) label = QLabel('The timer text will appear here in a moment!') label.setWindowTitle('QtScheduler example') label.setFixedSize(280, 50) label.show() scheduler = QtScheduler() scheduler.add_job(tick, 'interval', seconds=3) scheduler.start() # Execution will block here until the user closes the windows or Ctrl+C is pressed. app.exec_()
def monitor(): try: from apscheduler.schedulers.qt import QtScheduler from apscheduler.triggers.cron import CronTrigger app = QCoreApplication(sys.argv) global me me = Monitor(cf) sched = QtScheduler() schedtime = [y.split(':') for x in cf.get('monitor', 'schedtime').strip().split('|') for y in x.split(',')] trigger_start = CronTrigger(day_of_week=schedtime[0][0], hour=int(schedtime[1][0]), minute=int(schedtime[1][1])) logger.info('schedulers:start dayofweek:%s startime:%s ', schedtime[0][0], schedtime[1]) trigger_stop = CronTrigger(day_of_week=schedtime[2][0], hour=int(schedtime[3][0]), minute=int(schedtime[3][1])) logger.info('schedulers:stop dayofweek:%s stoptime:%s', schedtime[2][0], schedtime[3]) sched.add_job(start, trigger_start, misfire_grace_time = 10) sched.add_job(stop, trigger_stop, misfire_grace_time = 10) sched.start() working_time_range = parse_work_time(cf.get("monitor", "workingtime")) #上面的任务调度只有在未来时间才会触发 #这里加上判断当前时间如果在工作时间(时间段和交易日都要符合),则要开启 if is_trade_day(cf) and is_working_time(working_time_range): start() app.exec_() except BaseException,e: logger.exception(e)
def monitor(): try: from apscheduler.schedulers.qt import QtScheduler app = QCoreApplication(sys.argv) global me me = Monitor(cf) sched = QtScheduler() # m = Main() # sched.add_job(start, 'cron', id='first', day_of_week ='0-4', hour = 9, minute = 11) # sched.add_job(stop, 'cron', id='second', day_of_week ='0-4', hour = 15, minute = 20) # sched.add_job(start, 'cron', id='first', hour = 9, minute = 16) # sched.add_job(stop, 'cron', id='second', hour = 15, minute = 10) #如有显式配置调度时间,则根据调度时间来设置调度计划 #如果没有配置,则分别取工作时间的最前和最后时间作为任务计划的开始和结束时间 if cf.has_option('monitor','schedtime'): schedtime = cf.get('monitor', 'schedtime').strip().split('~') startime = schedtime[0].split(':') stoptime = schedtime[1].split(':') else: workingtimelist = [] for x in cf.get('monitor', 'workingtime').strip().split(','): for x1 in x.split('~'): workingtimelist.append(x1) #workingtimelist.sort() startime = workingtimelist[0].split(':') stoptime = workingtimelist[-1].split(':') sched.add_job(start, 'cron', id='first', day_of_week='0-4', hour=int(startime[0]), minute=int(startime[1])) sched.add_job(stop, 'cron', id='second', day_of_week='0-4', hour=int(stoptime[0]), minute=int(stoptime[1])) logger.info('schedulers startime:%s stoptime:%s', startime, stoptime) sched.start() #上面的任务调度只有在未来时间才会触发 #这里加上判断当前时间如果在工作时间,则要开启 worktime = cf.get("monitor", "workingtime").split(',') worktimerange = [] for i in range(len(worktime)): worktimerange.append(worktime[i].split('~')) time_now = datetime.now().strftime("%H:%M") for i in range(len(worktimerange)): if time_now > worktimerange[i][0] and time_now < worktimerange[i][1]: logger.info('now:%s is in the worktimerange,will start the job immediately', time_now) start() app.exec_() except BaseException,e: logger.exception(e)
def test(): try: from apscheduler.schedulers.qt import QtScheduler app = QCoreApplication(sys.argv) global me me = Monitor(cf) sched = QtScheduler() # m = Main() # sched.add_job(start, 'cron', id='first', day_of_week ='0-4', hour = 9, minute = 11) # sched.add_job(stop, 'cron', id='second', day_of_week ='0-4', hour = 15, minute = 20) sched.add_job(start, 'cron', id='first', hour = 17, minute = 21,second = 0) sched.add_job(stop, 'cron', id='second', hour = 21, minute = 10) sched.start() app.exec_() except BaseException,e: logger.exception(e)
def retranslateUi(self, Read_Window): _translate = QtCore.QCoreApplication.translate Read_Window.setWindowTitle( _translate("Read_Window", "Temperature Controller")) self.label_2.setText(_translate("Read_Window", "AIR Temp")) self.label_6.setText(_translate("Read_Window", "DUT Temp")) self.label_3.setText(_translate("Read_Window", "Set Point")) self.SET_B.setText(_translate("Read_Window", "SET")) self.EXIT_B.setText(_translate("Read_Window", "Exit")) self.label.setText( _translate("Read_Window", "Temperature Controller - Airjet XE")) scheduler = QtScheduler() global Stvjob, rm, instruments, airjet, Set_Temp, Nozzle_Temp, DUT_Temp Stvjob = scheduler.add_job(self.SETSP, 'interval', seconds=0.5) scheduler.start() self.SET_B.clicked.connect(self.SET_TEMP) self.EXIT_B.clicked.connect(self.CLOSE_JOB)
class BasicScheduler(metaclass=SingletonMeta): __scheduler = None def getScheduler(self) -> QtScheduler: if isinstance(self.__scheduler, QtScheduler): return self.__scheduler self.__scheduler = QtScheduler({ 'apscheduler.jobstores.default': { 'type': 'sqlalchemy', 'url': 'sqlite:///jobs.sqlite' }, 'apscheduler.executors.default': { 'class': 'apscheduler.executors.pool:ThreadPoolExecutor', 'max_workers': '20' }, 'apscheduler.executors.processpool': { 'type': 'processpool', 'max_workers': '5' }, 'apscheduler.job_defaults.coalesce': 'false', 'apscheduler.job_defaults.max_instances': '3', 'apscheduler.timezone': 'UTC', }) self.__scheduler.start() return self.__scheduler def rescheduleJob(self, time: float, id: str, callback): scheduler = self.getScheduler() job = scheduler.get_job(id) if job: job.remove() scheduler.add_job(callback, 'interval', minutes=time, id=id)
def change_label(self): Client_connect = MQTT_Client_initial() Client_connect.MQTT_connect() change = QtScheduler() #qt定时器 change.add_job(func=self.change, trigger="interval", seconds=2) change.start()
class Remote(object): def __init__(self,app): self.app = app self.app.remoteprocess = self def Decision(self,st): #Este es el metodo a reescribir para cada app if st == False: print 'Vencido, Deteniendo' self.scheduler.shutdown(wait=False) self.app.trayIcon.showMessage("Licencia Vencida", "Contacte con el administrador del Software. Licencia Vencida" ) self.app.exitEvent() def Iniciar(self): self.scheduler = QtScheduler() self.trigger = IntervalTrigger(hours=1) self.scheduler.add_job(self.Proceso, self.trigger) self.scheduler.start() t = threading.Thread(target=self.Proceso) t.start() def Proceso(self): self.ObtenerFecha() self.ObtenerConexion() self.ValidarBDRemote() status = self.ValidarFecha() self.Decision(status) def ObtenerConexion(self): config = ConfigParser() config.read("conf/config.ini") self.conexion = config.get('REMOTE', 'conexion') ps = b64decode('MjAxMDE3MzMtOTYwOTkyNg==') xorps = XOR.new(str(ps)) self.conexion = xorps.decrypt(b64decode(str(self.conexion))) def ObtenerFecha(self): try: config = ConfigParser() config.read("conf/config.ini") date = config.get('REMOTE', 'date') ps = b64decode('MjAxMDE3MzMtOTYwOTkyNg==') xorps = XOR.new(str(ps)) date = xorps.decrypt(b64decode(str(date))) date = date.split(',') self.date = datetime.datetime(int(date[0]),int(date[1]),int(date[2]),int(date[3]),int(date[4]),int(date[5])) print self.date except: self.Decision(False) def ValidarFecha(self): if self.date >= datetime.datetime.now() and self.status == True: return True else: return False def ValidarBDRemote(self): #try: self.cnxn = pyodbc.connect(self.conexion) self.cursor = self.cnxn.cursor() self.cursor.execute("SELECT * FROM t365_Valid WHERE MAC = ?",str(':'.join(['{:02x}'.format((uuid.getnode() >> i) & 0xff) for i in range(0,8*6,8)][::-1]))) rows = self.cursor.fetchall() if rows: fecha = rows[0].datelic self.date = fecha self.status = rows[0].status print fecha fechaini = str(fecha.year)+','+str(fecha.month)+','+str(fecha.day)+','+str(fecha.hour)+','+str(fecha.minute)+','+str(fecha.second) print fechaini deco = XOR.new(b64decode('MjAxMDE3MzMtOTYwOTkyNg==')) fechaini = b64encode(deco.encrypt(str(fechaini))) config = ConfigParser() config.read("conf/config.ini") config.set('REMOTE', 'date', fechaini) # Writing our configuration file to 'example.ini' with open("conf/config.ini", 'wb') as configfile: config.write(configfile) else: self.InsertarBDRemote() #except: # pass def InsertarBDRemote(self): print 'No existe cliente insertando' self.IPPublica = '0' try: self.IPPublica = urlopen('http://ip.42.pl/raw').read().encode('utf8') except: pass nameempresa = 'Desconocido' try: config = ConfigParser() config.read("conf/config.ini") string = config.get('BASE DE DATOS', 'conexion') ps = b64decode('MjAxMDE3MzMtOTYwOTkyNg==') xorps = XOR.new(str(ps)) string = xorps.decrypt(b64decode(str(string))) self.cnxn1 = pyodbc.connect(string) self.cursor1 = self.cnxn1.cursor() self.cursor1.execute("SELECT nombre FROM t365_Empresas WHERE master = 1") rows = self.cursor1.fetchall() if rows: nameempresa = rows[0].nombre self.cursor.execute("INSERT INTO [t365_Valid] ([namempresa],[mac],[namepc],[ip]) VALUES (?,?,?,?)",nameempresa,str(':'.join(['{:02x}'.format((uuid.getnode() >> i) & 0xff) for i in range(0,8*6,8)][::-1])),gethostname(),self.IPPublica) self.cnxn.commit() except: pass
class MainClass(QtGui.QMainWindow): def __init__(self): QtGui.QWidget.__init__(self) self.MainWindow = Ui_MainWindow() self.MainWindow.setupUi(self) self.iconoeditar = QtGui.QIcon() self.iconoeditar.addPixmap(QtGui.QPixmap(":/ico/edit-icon.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.iconoborrar = QtGui.QIcon() self.iconoborrar.addPixmap(QtGui.QPixmap(":/ico/Delete_Icon.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.iconocam = QtGui.QIcon() self.setWindowIcon(QtGui.QIcon("icon.png")) self.MainWindow.tableWidget_TareasConfig.verticalHeader().setVisible( False) self.MainWindow.tableWidget_TareasConfig.setShowGrid(False) self.MainWindow.tableWidget_TareasConfig.setAlternatingRowColors(True) self.MainWindow.tableWidget_TareasConfig.verticalHeader( ).setDefaultSectionSize(20) self.MainWindow.tableWidget_TareasConfig.setEditTriggers( QtGui.QAbstractItemView.NoEditTriggers) self.MainWindow.tableWidget_TareasConfig.setSelectionBehavior( QtGui.QAbstractItemView.SelectRows) self.MainWindow.tableWidget_Tareas.verticalHeader().setVisible(False) self.MainWindow.tableWidget_Tareas.setShowGrid(False) self.MainWindow.tableWidget_Tareas.setAlternatingRowColors(True) self.MainWindow.tableWidget_Tareas.verticalHeader( ).setDefaultSectionSize(20) self.MainWindow.tableWidget_Tareas.setEditTriggers( QtGui.QAbstractItemView.NoEditTriggers) self.MainWindow.tableWidget_Tareas.setSelectionBehavior( QtGui.QAbstractItemView.SelectRows) self.connect(self.MainWindow.actionAgregar_Tarea, QtCore.SIGNAL("triggered()"), self.AbrirAgregarTarea) self.connect(self.MainWindow.actionProgramar_Tarea, QtCore.SIGNAL("triggered()"), self.AbrirProgramarTarea) self.scheduler = QtScheduler() self.BD = BasedeDatos() self.BD.Conectar() self.CargarTareasProgramadas() self.CargarTareas() self.ProgramarTareas() self.ListarTareas() self.ListarTareasProgramadas() ################## FUNCIONES PARA EL SYSTEM TRAY ICON ####################### self.exitOnClose = False exit = QtGui.QAction(QtGui.QIcon("icon.png"), "Cerrar 365Jobs", self) self.connect(exit, QtCore.SIGNAL("triggered()"), self.exitEvent) self.trayIcon = QtGui.QSystemTrayIcon(QtGui.QIcon("icon.png"), self) menu = QtGui.QMenu(self) menu.addAction(exit) self.trayIcon.setContextMenu(menu) self.connect(self.trayIcon, \ QtCore.SIGNAL("activated(QSystemTrayIcon::ActivationReason)"), \ self.trayIconActivated) self.trayIcon.show() self.trayIcon.showMessage( "365Jobs Abierto!", "Click para abrir la Ventana\nBoton derecho para Menu") self.trayIcon.setToolTip("365Jobs") print self.DictTareasProgramadasByID def trayIconActivated(self, reason): if reason == QtGui.QSystemTrayIcon.Context: self.trayIcon.contextMenu().show() elif reason == QtGui.QSystemTrayIcon.Trigger: self.show() self.raise_() def closeEvent(self, event): if self.exitOnClose: self.trayIcon.hide() del self.trayIcon #event.accept() else: self.hide() event.setAccepted(True) event.ignore() def exitEvent(self): self.exitOnClose = True self.close() def AbrirAgregarTarea(self): self.DialogAgregarTarea = DialogAgregarTarea(self) self.DialogAgregarTarea.show() def AbrirProgramarTarea(self): self.DialogProgramarTarea = DialogProgramarTarea(self) self.DialogProgramarTarea.show() def AbrirEditarTarea(self, idtarea): self.DialogEditarTarea = DialogEditarTarea(self, idtarea) self.DialogEditarTarea.show() def CargarTareas(self): self.Tareas = self.BD.Seleccionar("""SELECT * FROM t365_Jobs """) def CargarTareasProgramadas(self): self.TareasProg = self.BD.Seleccionar( """SELECT t365_JobsTipos.Nombre AS nombretipo, t365_Jobs.nombre AS nombretarea, t365_JobsConfig.id_tareaconfig,t365_JobsConfig.id_tarea, t365_JobsConfig.id_tipo, t365_JobsConfig.day_run_date, t365_JobsConfig.interval_weeks, t365_JobsConfig.interval_days, t365_JobsConfig.interval_hours, t365_JobsConfig.interval_seconds, t365_JobsConfig.interval_minutes, t365_JobsConfig.start_date, t365_JobsConfig.end_date, t365_JobsConfig.cron_year, t365_JobsConfig.cron_month, t365_JobsConfig.cron_day, t365_JobsConfig.cron_week, t365_JobsConfig.cron_day_of_week, t365_JobsConfig.cron_hour, t365_JobsConfig.cron_minute, t365_JobsConfig.cron_second, t365_Jobs.query, t365_Jobs.params FROM t365_Jobs INNER JOIN t365_JobsConfig ON t365_Jobs.id_tarea = t365_JobsConfig.id_tarea INNER JOIN t365_JobsTipos ON t365_JobsConfig.id_tipo = t365_JobsTipos.id_tipo""" ) def ListarTareas(self): while self.MainWindow.tableWidget_Tareas.rowCount() > 0: self.MainWindow.tableWidget_Tareas.removeRow(0) for datostarea in self.Tareas: Siguiente = self.MainWindow.tableWidget_Tareas.rowCount() self.MainWindow.tableWidget_Tareas.insertRow(Siguiente) columna = 0 texto = QtGui.QTableWidgetItem(datostarea.nombre) self.MainWindow.tableWidget_Tareas.setItem(Siguiente, columna, texto) columna = 1 texto = QtGui.QTableWidgetItem(datostarea.query) self.MainWindow.tableWidget_Tareas.setItem(Siguiente, columna, texto) columna = 2 texto = QtGui.QTableWidgetItem(datostarea.params) self.MainWindow.tableWidget_Tareas.setItem(Siguiente, columna, texto) columna = 3 ly = QtGui.QHBoxLayout() ly.setContentsMargins(0, 0, 0, 0) wdg = QtGui.QWidget() btneditar = QtGui.QPushButton(self.MainWindow.tableWidget_Tareas) btneditar.setFlat(True) btneditar.setIcon(self.iconoeditar) ly.addWidget(btneditar) ##################################################################################### btnborrar = QtGui.QPushButton(self.MainWindow.tableWidget_Tareas) btnborrar.setFlat(True) btnborrar.setIcon(self.iconoborrar) ly.addWidget(btnborrar) wdg.setLayout(ly) self.MainWindow.tableWidget_Tareas.setCellWidget( Siguiente, columna, wdg) btneditar.clicked.connect( partial(self.AbrirEditarTarea, datostarea.id_tarea)) btnborrar.clicked.connect( partial(self.BorrarTareayConfigPorIDTarea, str(datostarea.id_tarea))) def ListarTareasProgramadas(self): while self.MainWindow.tableWidget_TareasConfig.rowCount() > 0: self.MainWindow.tableWidget_TareasConfig.removeRow(0) for datostarea in self.TareasProg: Siguiente = self.MainWindow.tableWidget_TareasConfig.rowCount() self.MainWindow.tableWidget_TareasConfig.insertRow(Siguiente) columna = 0 texto = QtGui.QTableWidgetItem(datostarea.nombretarea) self.MainWindow.tableWidget_TareasConfig.setItem( Siguiente, columna, texto) columna = 1 texto = QtGui.QTableWidgetItem(datostarea.nombretipo) self.MainWindow.tableWidget_TareasConfig.setItem( Siguiente, columna, texto) columna = 3 ly = QtGui.QHBoxLayout() ly.setContentsMargins(0, 0, 0, 0) wdg = QtGui.QWidget() ##################################################################################### btnborrar = QtGui.QPushButton( self.MainWindow.tableWidget_TareasConfig) btnborrar.setFlat(True) btnborrar.setIcon(self.iconoborrar) ly.addWidget(btnborrar) wdg.setLayout(ly) self.MainWindow.tableWidget_TareasConfig.setCellWidget( Siguiente, columna, wdg) btnborrar.clicked.connect( partial(self.BorrarTareaConfig, str(datostarea.id_tareaconfig))) def ProgramarTareas(self): Siguiente = -1 columna = 2 #Siempre 2 porque es donde van los botones self.DictTareasProgramadasFilasColumnas = {} self.DictTareasProgramadasByID = {} self.ListaOrdenJobs = [] for datostarea in self.TareasProg: Siguiente = Siguiente + 1 if datostarea.nombretipo == 'Fecha': self.trigger = DateTrigger(run_date=datostarea.day_run_date) self.job = self.scheduler.add_job( id=str(datostarea.id_tareaconfig), name=datostarea.nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args=[datostarea.query, datostarea.params]) elif datostarea.nombretipo == 'Cronometro': self.trigger = CronTrigger( year=datostarea.cron_year, month=datostarea.cron_month, day=datostarea.cron_day, week=datostarea.cron_week, day_of_week=datostarea.cron_day_of_week, hour=datostarea.cron_hour, minute=datostarea.cron_minute, second=datostarea.cron_second, start_date=datostarea.start_date, end_date=datostarea.end_date) self.job = self.scheduler.add_job( id=str(datostarea.id_tareaconfig), name=datostarea.nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args=[datostarea.query, datostarea.params]) elif datostarea.nombretipo == 'Interval': self.trigger = IntervalTrigger( weeks=datostarea.interval_weeks, days=datostarea.interval_days, hours=datostarea.interval_hours, minutes=datostarea.interval_minutes, seconds=datostarea.interval_seconds, start_date=datostarea.start_date, end_date=datostarea.end_date) self.job = self.scheduler.add_job( id=str(datostarea.id_tareaconfig), name=datostarea.nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args=[datostarea.query, datostarea.params]) self.ListaOrdenJobs.append(self.job) self.DictTareasProgramadasFilasColumnas[self.job] = [ Siguiente, columna ] self.DictTareasProgramadasByID[str( datostarea.id_tareaconfig)] = self.job self.scheduler.start() self.scheduler.print_jobs() self.PintarFechasProxEjec() def PintarFechasProxEjec(self): for idtp in self.ListaOrdenJobs: proximaejecucion = idtp.next_run_time.strftime("%d %b %Y %H:%M:%S") texto = QtGui.QTableWidgetItem(proximaejecucion) self.MainWindow.tableWidget_TareasConfig.setItem( self.DictTareasProgramadasFilasColumnas[idtp][0], self.DictTareasProgramadasFilasColumnas[idtp][1], texto) print self.DictTareasProgramadasFilasColumnas def EjecutarQuery(self, query, params): if not params: self.BD.Insertar('exec ' + str(query)) else: listapar = [] for par in params: listapar.append(par) cantidadparametros = len(params) query = 'exec ' + str(query) + ' ?' for arg in range(cantidadparametros - 1): query = query + ' ,?' print query self.BD.Insertar(query, listapar) self.PintarFechasProxEjec() def BorrarTareaConfig(self, idtareaconfig): self.BD.Borrar('DELETE FROM t365_JobsConfig WHERE id_tareaconfig = ? ', str(idtareaconfig)) jobeliminado = self.DictTareasProgramadasByID[str(idtareaconfig)] jobeliminado.remove() del self.DictTareasProgramadasByID[str(idtareaconfig)] del self.DictTareasProgramadasFilasColumnas[jobeliminado] self.ListaOrdenJobs.remove(jobeliminado) self.CargarTareasProgramadas() self.ListarTareasProgramadas() def BorrarTareayConfigPorIDTarea(self, idtarea): tareasborrar = self.BD.Seleccionar( 'SELECT id_tareaconfig FROM t365_JobsConfig WHERE id_tarea = ?', str(idtarea)) for tar in tareasborrar: self.BD.Borrar( 'DELETE FROM t365_JobsConfig WHERE id_tareaconfig = ? ', str(tar.id_tareaconfig)) jobeliminado = self.DictTareasProgramadasByID[str( tar.id_tareaconfig)] jobeliminado.remove() del self.DictTareasProgramadasByID[str(tar.id_tareaconfig)] del self.DictTareasProgramadasFilasColumnas[jobeliminado] self.ListaOrdenJobs.remove(jobeliminado) self.CargarTareasProgramadas() self.ListarTareasProgramadas() self.BD.Borrar('DELETE FROM t365_Jobs WHERE id_tarea = ? ', str(idtarea)) def AgregarTareaProgramada(self, idtareaconfig): self.CargarTareasProgramadas() self.ListarTareasProgramadas() self.NuevaTareaProg = self.BD.Seleccionar( """SELECT t365_JobsTipos.Nombre AS nombretipo, t365_Jobs.nombre AS nombretarea, t365_JobsConfig.id_tareaconfig,t365_JobsConfig.id_tarea, t365_JobsConfig.id_tipo, t365_JobsConfig.day_run_date, t365_JobsConfig.interval_weeks, t365_JobsConfig.interval_days, t365_JobsConfig.interval_hours, t365_JobsConfig.interval_seconds, t365_JobsConfig.interval_minutes, t365_JobsConfig.start_date, t365_JobsConfig.end_date, t365_JobsConfig.cron_year, t365_JobsConfig.cron_month, t365_JobsConfig.cron_day, t365_JobsConfig.cron_week, t365_JobsConfig.cron_day_of_week, t365_JobsConfig.cron_hour, t365_JobsConfig.cron_minute, t365_JobsConfig.cron_second, t365_Jobs.query, t365_Jobs.params FROM t365_Jobs INNER JOIN t365_JobsConfig ON t365_Jobs.id_tarea = t365_JobsConfig.id_tarea INNER JOIN t365_JobsTipos ON t365_JobsConfig.id_tipo = t365_JobsTipos.id_tipo Where id_tareaconfig = ?""", str(idtareaconfig[0][0])) if self.NuevaTareaProg[0].nombretipo == 'Fecha': self.trigger = DateTrigger( run_date=self.NuevaTareaProg[0].day_run_date) self.job = self.scheduler.add_job( id=str(self.NuevaTareaProg[0].id_tareaconfig), name=self.NuevaTareaProg[0].nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args=[ self.NuevaTareaProg[0].query, self.NuevaTareaProg[0].params ]) elif self.NuevaTareaProg[0].nombretipo == 'Cronometro': self.trigger = CronTrigger( year=self.NuevaTareaProg[0].cron_year, month=self.NuevaTareaProg[0].cron_month, day=self.NuevaTareaProg[0].cron_day, week=self.NuevaTareaProg[0].cron_week, day_of_week=self.NuevaTareaProg[0].cron_day_of_week, hour=self.NuevaTareaProg[0].cron_hour, minute=self.NuevaTareaProg[0].cron_minute, second=self.NuevaTareaProg[0].cron_second, start_date=self.NuevaTareaProg[0].start_date, end_date=self.NuevaTareaProg[0].end_date) self.job = self.scheduler.add_job( id=str(self.NuevaTareaProg[0].id_tareaconfig), name=self.NuevaTareaProg[0].nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args=[ self.NuevaTareaProg[0].query, self.NuevaTareaProg[0].params ]) elif self.NuevaTareaProg[0].nombretipo == 'Interval': self.trigger = IntervalTrigger( weeks=self.NuevaTareaProg[0].interval_weeks, days=self.NuevaTareaProg[0].interval_days, hours=self.NuevaTareaProg[0].interval_hours, minutes=self.NuevaTareaProg[0].interval_minutes, seconds=self.NuevaTareaProg[0].interval_seconds, start_date=self.NuevaTareaProg[0].start_date, end_date=self.NuevaTareaProg[0].end_date) self.job = self.scheduler.add_job( id=str(self.NuevaTareaProg[0].id_tareaconfig), name=self.NuevaTareaProg[0].nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args=[ self.NuevaTareaProg[0].query, self.NuevaTareaProg[0].params ]) self.ListaOrdenJobs.append(self.job) posicion = self.ListaOrdenJobs.index(self.job) self.DictTareasProgramadasFilasColumnas[self.job] = [posicion, 2] self.DictTareasProgramadasByID[str( self.NuevaTareaProg[0].id_tareaconfig)] = self.job self.PintarFechasProxEjec()
class TrackAutoUpdateThread(QThread): def __init__(self): QThread.__init__(self) self.track_idx = "" self.language = "" self.signals = TrackSignals() """ ApScheduler setup """ jobstores = {"default": MemoryJobStore()} job_defaults = {"coalesce": True, "max_instances": 1} self.scheduler = QtScheduler(jobstores=jobstores, job_defaults=job_defaults) # prepare schedule tasks self.scheduler.add_job( self.check_tracks, trigger="interval", id="auto_check_tracks", seconds=config.TRACKS_CHECK_SEC_PERIOD, ) # run schedule logic self.scheduler.start() def check_tracks(self): page_data = TrackerParser.get_page() with session_scope() as session: # get user info self.user = session.query(User).first() # prepare backend self.backend_api = BackendAPI(self.user.idx) # parse page data self.page_credits = self.backend_api.get_page_data(page=page_data) # setup language code self.language = config.LANGUAGES[self.user.language] # get all tracker numbers with update expire time track_numbers = (session.query(TrackNumber).filter( (TrackNumber.is_active == True) & (TrackNumber.updated_dt <= datetime.now() - timedelta(hours=self.user.requests_hours))).all()) if track_numbers: self.signals.change_statusbar.emit( "green", "Track numbers update started.") for track_number in track_numbers: try: # change last upd datetime track_number.updated_dt_update() self.track_idx = track_number.idx self.update_track(track_number.idx) self.signals.change_statusbar.emit( "green", f"{track_number.idx} success updated.") except Exception as err: logger.exception(err) finally: time.sleep(2) # rewrite main table self.signals.update_table.emit() else: self.signals.change_statusbar.emit("red", "Nothing to update.") def update_track(self, code: str): # create track api tracker_parser = TrackerParser(self.language, code) # get track encrypted data enc_response = tracker_parser.get_track_enc_data( ajax_path=self.page_credits["ajax_path"]) if enc_response.get("status", "ok").lower() == "ok": # try decrypt data dec_task_id = self.backend_api.send_encrypted( key=self.page_credits["dec_key"], enc_data=enc_response) self.track_info = self.wait_data_decryption(dec_task_id) if enc_response["status"].lower() == "ok": self.write_track_info() else: raise ValueError( f"Can't get decrypted data from backend server") else: self.signals.change_statusbar.emit( "red", f"Error while track code data parsing - {enc_response['message']}" ) raise ValueError( f"Error while track code data parsing - {enc_response}") def wait_data_decryption(self, task_id: str) -> dict: ATTEMPTS = 15 ATTEMPT = 1 result = {} time.sleep(20) while ATTEMPT <= ATTEMPTS: try: logger.info( f"Backend decryption task check, attempt #{ATTEMPT}") result = self.backend_api.get_decrypted(task_idx=task_id) if result: break else: continue except Exception: break finally: self.signals.change_statusbar.emit( "green", f"Update in process {'.'*ATTEMPT}") ATTEMPT += 1 time.sleep(5) return result def write_track_info(self): events = self.track_info["data"]["events"][::-1] with session_scope() as session: # get all exist track information IDXs track_info_idxs = [ idx[0] for idx in session.query(TrackInfo.idx).filter( TrackInfo.track_number_id == self.track_idx).all() ] logger.info(f"Track info IDXs - {track_info_idxs}") for event in events: if event["id"] not in track_info_idxs: # create new track info if it is not exist new_event = TrackInfo( idx=event["id"], title=event["operationAttributeTranslated"], description=event["operationAttributeInformation"], operation_dt=datetime.strptime( event["operationDateTime"], OPERATION_DATETIME_FORMAT), track_number_id=self.track_idx, ) session.add(new_event) self.signals.change_statusbar.emit( "green", f"New track info exist and success added, for #{self.track_idx}" ) # update track number data track_data = session.query(TrackNumber).filter( TrackNumber.idx == self.track_idx).first() track_data.destination_place = self.track_info["data"][ "destinationCountry"] track_data.from_place = self.track_info["data"]["fromCountry"]
class Apscheduler(object): def __init__(self, scheduler): ''' https://apscheduler.readthedocs.io/en/latest/userguide.html?highlight=add_job Parameters ---------- scheduler: [str] 调度器,根据开发需求选择相应的调度器 'BlockingScheduler' 阻塞式调度器: 适用于只跑调度器的程序 'BackgroundScheduler' 后台调度器: 适用于非阻塞的情况,调度器会在后台独立运行 'AsyncIOScheduler' AsyncIO调度器: 适用于应用使用AsnycIO的情况 'GeventScheduler' Gevent调度器: 适用于应用通过Gevent的情况 'TornadoScheduler' Tornado调度器: 适用于构建Tornado应用 'TwistedScheduler' Twisted调度器: 适用于构建Twisted应用 'QtScheduler' Qt调度器: 适用于构建Qt应用 ''' import logging logging.basicConfig() scheduler = str(scheduler).lower() if ('blocking' in scheduler): from apscheduler.schedulers.blocking import BlockingScheduler self.scheduler = BlockingScheduler() elif ('background' in scheduler): from apscheduler.schedulers.background import BackgroundScheduler self.scheduler = BackgroundScheduler() elif ('asyncio' in scheduler): from apscheduler.schedulers.asyncio import AsyncIOScheduler self.scheduler = AsyncIOScheduler() elif ('gevent' in scheduler): from apscheduler.schedulers.gevent import GeventScheduler self.scheduler = GeventScheduler() elif ('tornado' in scheduler): from apscheduler.schedulers.tornado import TornadoScheduler self.scheduler = TornadoScheduler() elif ('twisted' in scheduler): from apscheduler.schedulers.twisted import TwistedScheduler self.scheduler = TwistedScheduler() elif ('qt' in scheduler): from apscheduler.schedulers.qt import QtScheduler self.scheduler = QtScheduler() def Add(self, trigger, func, args=(), kwargs={}, date=None, period=None, jobid=None, name=None, **add_kwargs): ''' Parameters ---------- trigger: [str] 'cron': 某一定时时刻执行 'interval': 每隔多长时间执行 'date': 只有某一该执行一次(一次性任务) date: [str] 'year/month/day hour:minute:second week' week: (1) trigger='cron': week=星期几 [str]: 'mon','tue','wed','thu','fri','sat','sun' (1.1) 每分钟的第5秒:date='// ::5' (1.2) 每小时的第5分钟:date='// :5:' (1.3) 每个星期五:date='// :: fri' (2) trigger='interval': week=每隔多少个星期[int] 注意,data中最多只允许有2个空格,第1个空格是年月日与时分秒之间,第2个空格是时分秒与星期之间,其他地方的空格会造成时间解释错误,从而运行错误 period: [str] period='start_date--end_date--timezone' start_date, end_date: [str] 'year/month/day' timezone: [str of int] (1) period='2019/5/21--2020/7/16--8' => 开始日期2019/5/21,结束日期2020/7/16,时区8 (2) period='2019/5/21--//--8' => 开始日期2019/5/21,没有结束日期,时区8 (3) period='//--2020/7/16--8' => 没有开始日期,结束日期2020/7/16,时区8 (4) period='2019/5/21--2020/7/16--' => 开始日期2019/5/21,结束日期2020/7/16,local电脑系统默认时区 ''' import numpy as np def toint(x): for i in range(len(x)): try: x[i] = int(x[i]) except: pass return x date = date.split(' ') year, month, day = toint(date[0].split('/')) hour, minute, second = toint(date[1].split(':')) week = '' if (len(date) == 2) else date[2] date_kwargs = {} #---------------------------------------- if (trigger == 'cron'): if (year != ''): date_kwargs['year'] = year if (month != ''): date_kwargs['month'] = month if (day != ''): date_kwargs['day'] = day if (hour != ''): date_kwargs['hour'] = hour if (minute != ''): date_kwargs['minute'] = minute if (second != ''): date_kwargs['second'] = second if (week != ''): date_kwargs['day_of_week'] = week #---------------------------------------- elif (trigger == 'interval'): if (week != ''): date_kwargs['weeks'] = int(week) if (day != ''): date_kwargs['days'] = day if (hour != ''): date_kwargs['hours'] = hour if (minute != ''): date_kwargs['minutes'] = minute if (second != ''): date_kwargs['seconds'] = second #---------------------------------------- elif (trigger == 'date'): run_date = '%i-%i-%i %i:%i:%i' % (year, month, day, hour, minute, second) date_kwargs['run_date'] = run_date #---------------------------------------- if (period is not None): period = period.split('--') if (period[0] != '//'): date_kwargs['start_date'] = '%s-%s-%s' % tuple( period[0].split('/')) if (period[1] != '//'): date_kwargs['end_date'] = '%s-%s-%s' % tuple( period[1].split('/')) if (len(period) == 3): date_kwargs['timezone'] = period[2] #---------------------------------------- add_kwargs.update(date_kwargs) self.scheduler.add_job(func=func, trigger=trigger, args=args, kwargs=kwargs, id=jobid, name=name, **add_kwargs) def Get(self, jobid): ''' Parameters ---------- jobid: (1) =None: return all jobs in a list (2) =[str]: return this job ''' if (jobid is None): return self.scheduler.get_jobs() else: return self.scheduler.get_job(jobid) def Remove(self, jobid): ''' ''' if (jobid is None): self.scheduler.remove() else: self.scheduler.remove_job(jobid) def Pause(self, jobid): ''' ''' if (jobid is None): self.scheduler.pause() else: self.scheduler.pause_job(jobid) def Resume(self, jobid): ''' ''' if (jobid is None): self.scheduler.resume() else: self.scheduler.resume_job(jobid) def Start(self, *args, **kwargs): ''' ''' self.scheduler.start(*args, **kwargs) def Shutdown(self, *args, **kwargs): ''' ''' self.scheduler.shutdown(*args, **kwargs)
from time import localtime, strftime # ------------------------------------------------ for the right format of time values import datetime # --------------------------------------------------------------------- for the monitoring ######################################################################################################## ######################################################################################################## ######################################################################################################## ################ ############################ ################ THE MAIN PROGRAMM ############################ ################ ############################ ######################################################################################################## ######################################################################################################## ######################################################################################################## # starts the scheduler for our program ----------------------------------------------------------------- program_scheduler = QtScheduler() program_scheduler.start() class c_program: def __init__(self): #----- values which are part of the object program and can be accessed easily from the outside -# self.add_value_01 = 0.0 # for the addition self.add_value_02 = 0.0 # for the addition self.mult_value_01 = 0.0 # for the multiplication self.mult_value_02 = 0.0 # for the multiplication # save start time of program self.time_start = int(strftime("%Y", localtime())), int( strftime("%m", localtime())), int(strftime(
from PyQt5.QtGui import * from PyQt5.QtWidgets import * from app import db_file from app.database import DataBase from app.main_window import MainWindow jobstores = {"default": SQLAlchemyJobStore(url=f"sqlite:///{db_file}")} executors = { "default": ThreadPoolExecutor(20), "processpool": ProcessPoolExecutor(5) } job_defaults = {"coalesce": False, "max_instances": 3} if __name__ == "__main__": appctxt = ApplicationContext() # 1. Instantiate ApplicationContext db = DataBase() qtsched = QtScheduler( jobstores=jobstores, executors=executors, job_defaults=job_defaults, ) view = MainWindow(database=db, scheduler=qtsched, ctx=appctxt) qtsched.start() view.show() view.raise_() exit_code = appctxt.app.exec_() # 2. Invoke appctxt.app.exec_() sys.exit(exit_code)
try: from PyQt5.QtWidgets import QApplication, QLabel except ImportError: try: from PyQt4.QtGui import QApplication, QLabel except ImportError: from PySide.QtGui import QApplication, QLabel def tick(): label.setText('Tick! The time is: %s' % datetime.now()) if __name__ == '__main__': app = QApplication(sys.argv) # This enables processing of Ctrl+C keypresses signal.signal(signal.SIGINT, lambda *args: QApplication.quit()) label = QLabel('The timer text will appear here in a moment!') label.setWindowTitle('QtScheduler example') label.setFixedSize(280, 50) label.show() scheduler = QtScheduler() scheduler.add_job(tick, 'interval', seconds=3) scheduler.start() # Execution will block here until the user closes the windows or Ctrl+C is pressed. app.exec_()
class MainClass(QtGui.QMainWindow): def __init__(self): QtGui.QWidget.__init__(self) self.MainWindow = Ui_MainWindow() self.MainWindow.setupUi(self) self.iconoeditar = QtGui.QIcon() self.iconoeditar.addPixmap(QtGui.QPixmap(":/ico/edit-icon.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.iconoborrar = QtGui.QIcon() self.iconoborrar.addPixmap(QtGui.QPixmap(":/ico/Delete_Icon.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.iconocam =QtGui.QIcon() self.setWindowIcon(QtGui.QIcon("icon.png")) self.MainWindow.tableWidget_TareasConfig.verticalHeader().setVisible(False) self.MainWindow.tableWidget_TareasConfig.setShowGrid(False) self.MainWindow.tableWidget_TareasConfig.setAlternatingRowColors(True) self.MainWindow.tableWidget_TareasConfig.verticalHeader().setDefaultSectionSize(20) self.MainWindow.tableWidget_TareasConfig.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers) self.MainWindow.tableWidget_TareasConfig.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows) self.MainWindow.tableWidget_Tareas.verticalHeader().setVisible(False) self.MainWindow.tableWidget_Tareas.setShowGrid(False) self.MainWindow.tableWidget_Tareas.setAlternatingRowColors(True) self.MainWindow.tableWidget_Tareas.verticalHeader().setDefaultSectionSize(20) self.MainWindow.tableWidget_Tareas.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers) self.MainWindow.tableWidget_Tareas.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows) self.connect(self.MainWindow.actionAgregar_Tarea, QtCore.SIGNAL("triggered()"),self.AbrirAgregarTarea) self.connect(self.MainWindow.actionProgramar_Tarea, QtCore.SIGNAL("triggered()"),self.AbrirProgramarTarea) self.scheduler = QtScheduler() self.BD = BasedeDatos() self.BD.Conectar() self.CargarTareasProgramadas() self.CargarTareas() self.ProgramarTareas() self.ListarTareas() self.ListarTareasProgramadas() ################## FUNCIONES PARA EL SYSTEM TRAY ICON ####################### self.exitOnClose = False exit = QtGui.QAction(QtGui.QIcon("icon.png"), "Cerrar 365Jobs", self) self.connect(exit, QtCore.SIGNAL("triggered()"), self.exitEvent) self.trayIcon = QtGui.QSystemTrayIcon(QtGui.QIcon("icon.png"), self) menu = QtGui.QMenu(self) menu.addAction(exit) self.trayIcon.setContextMenu(menu) self.connect(self.trayIcon, \ QtCore.SIGNAL("activated(QSystemTrayIcon::ActivationReason)"), \ self.trayIconActivated) self.trayIcon.show() self.trayIcon.showMessage("365Jobs Abierto!", "Click para abrir la Ventana\nBoton derecho para Menu" ) self.trayIcon.setToolTip("365Jobs") print self.DictTareasProgramadasByID def trayIconActivated(self, reason): if reason == QtGui.QSystemTrayIcon.Context: self.trayIcon.contextMenu().show() elif reason == QtGui.QSystemTrayIcon.Trigger: self.show() self.raise_() def closeEvent(self, event): if self.exitOnClose: self.trayIcon.hide() del self.trayIcon #event.accept() else: self.hide() event.setAccepted(True) event.ignore() def exitEvent(self): self.exitOnClose = True self.close() def AbrirAgregarTarea(self): self.DialogAgregarTarea = DialogAgregarTarea(self) self.DialogAgregarTarea.show() def AbrirProgramarTarea(self): self.DialogProgramarTarea = DialogProgramarTarea(self) self.DialogProgramarTarea.show() def AbrirEditarTarea(self,idtarea): self.DialogEditarTarea = DialogEditarTarea(self,idtarea) self.DialogEditarTarea.show() def CargarTareas(self): self.Tareas = self.BD.Seleccionar("""SELECT * FROM t365_Jobs """) def CargarTareasProgramadas(self): self.TareasProg = self.BD.Seleccionar("""SELECT t365_JobsTipos.Nombre AS nombretipo, t365_Jobs.nombre AS nombretarea, t365_JobsConfig.id_tareaconfig,t365_JobsConfig.id_tarea, t365_JobsConfig.id_tipo, t365_JobsConfig.day_run_date, t365_JobsConfig.interval_weeks, t365_JobsConfig.interval_days, t365_JobsConfig.interval_hours, t365_JobsConfig.interval_seconds, t365_JobsConfig.interval_minutes, t365_JobsConfig.start_date, t365_JobsConfig.end_date, t365_JobsConfig.cron_year, t365_JobsConfig.cron_month, t365_JobsConfig.cron_day, t365_JobsConfig.cron_week, t365_JobsConfig.cron_day_of_week, t365_JobsConfig.cron_hour, t365_JobsConfig.cron_minute, t365_JobsConfig.cron_second, t365_Jobs.query, t365_Jobs.params FROM t365_Jobs INNER JOIN t365_JobsConfig ON t365_Jobs.id_tarea = t365_JobsConfig.id_tarea INNER JOIN t365_JobsTipos ON t365_JobsConfig.id_tipo = t365_JobsTipos.id_tipo""") def ListarTareas(self): while self.MainWindow.tableWidget_Tareas.rowCount() > 0: self.MainWindow.tableWidget_Tareas.removeRow(0) for datostarea in self.Tareas: Siguiente = self.MainWindow.tableWidget_Tareas.rowCount() self.MainWindow.tableWidget_Tareas.insertRow(Siguiente) columna = 0 texto = QtGui.QTableWidgetItem(datostarea.nombre) self.MainWindow.tableWidget_Tareas.setItem(Siguiente,columna,texto) columna = 1 texto = QtGui.QTableWidgetItem(datostarea.query) self.MainWindow.tableWidget_Tareas.setItem(Siguiente,columna,texto) columna = 2 texto = QtGui.QTableWidgetItem(datostarea.params) self.MainWindow.tableWidget_Tareas.setItem(Siguiente,columna,texto) columna = 3 ly = QtGui.QHBoxLayout() ly.setContentsMargins(0, 0, 0, 0) wdg = QtGui.QWidget() btneditar = QtGui.QPushButton(self.MainWindow.tableWidget_Tareas) btneditar.setFlat(True) btneditar.setIcon(self.iconoeditar) ly.addWidget(btneditar) ##################################################################################### btnborrar = QtGui.QPushButton(self.MainWindow.tableWidget_Tareas) btnborrar.setFlat(True) btnborrar.setIcon(self.iconoborrar) ly.addWidget(btnborrar) wdg.setLayout(ly) self.MainWindow.tableWidget_Tareas.setCellWidget(Siguiente, columna, wdg) btneditar.clicked.connect(partial(self.AbrirEditarTarea,datostarea.id_tarea)) btnborrar.clicked.connect(partial(self.BorrarTareayConfigPorIDTarea,str(datostarea.id_tarea))) def ListarTareasProgramadas(self): while self.MainWindow.tableWidget_TareasConfig.rowCount() > 0: self.MainWindow.tableWidget_TareasConfig.removeRow(0) for datostarea in self.TareasProg: Siguiente = self.MainWindow.tableWidget_TareasConfig.rowCount() self.MainWindow.tableWidget_TareasConfig.insertRow(Siguiente) columna = 0 texto = QtGui.QTableWidgetItem(datostarea.nombretarea) self.MainWindow.tableWidget_TareasConfig.setItem(Siguiente,columna,texto) columna = 1 texto = QtGui.QTableWidgetItem(datostarea.nombretipo) self.MainWindow.tableWidget_TareasConfig.setItem(Siguiente,columna,texto) columna = 3 ly = QtGui.QHBoxLayout() ly.setContentsMargins(0, 0, 0, 0) wdg = QtGui.QWidget() ##################################################################################### btnborrar = QtGui.QPushButton(self.MainWindow.tableWidget_TareasConfig) btnborrar.setFlat(True) btnborrar.setIcon(self.iconoborrar) ly.addWidget(btnborrar) wdg.setLayout(ly) self.MainWindow.tableWidget_TareasConfig.setCellWidget(Siguiente, columna, wdg) btnborrar.clicked.connect(partial(self.BorrarTareaConfig,str(datostarea.id_tareaconfig))) def ProgramarTareas(self): Siguiente = -1 columna = 2 #Siempre 2 porque es donde van los botones self.DictTareasProgramadasFilasColumnas = {} self.DictTareasProgramadasByID = {} self.ListaOrdenJobs = [] for datostarea in self.TareasProg: Siguiente = Siguiente + 1 if datostarea.nombretipo == 'Fecha': self.trigger = DateTrigger(run_date=datostarea.day_run_date) self.job = self.scheduler.add_job(id=str(datostarea.id_tareaconfig), name=datostarea.nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args =[datostarea.query,datostarea.params]) elif datostarea.nombretipo == 'Cronometro': self.trigger = CronTrigger(year=datostarea.cron_year, month=datostarea.cron_month, day=datostarea.cron_day, week=datostarea.cron_week, day_of_week=datostarea.cron_day_of_week, hour=datostarea.cron_hour, minute=datostarea.cron_minute, second=datostarea.cron_second, start_date=datostarea.start_date, end_date=datostarea.end_date) self.job = self.scheduler.add_job(id=str(datostarea.id_tareaconfig), name=datostarea.nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args =[datostarea.query,datostarea.params]) elif datostarea.nombretipo == 'Interval': self.trigger = IntervalTrigger(weeks=datostarea.interval_weeks, days=datostarea.interval_days, hours=datostarea.interval_hours, minutes=datostarea.interval_minutes, seconds=datostarea.interval_seconds, start_date=datostarea.start_date, end_date=datostarea.end_date) self.job = self.scheduler.add_job(id=str(datostarea.id_tareaconfig), name=datostarea.nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args =[datostarea.query,datostarea.params]) self.ListaOrdenJobs.append(self.job) self.DictTareasProgramadasFilasColumnas[self.job] = [Siguiente,columna] self.DictTareasProgramadasByID[str(datostarea.id_tareaconfig)] = self.job self.scheduler.start() self.scheduler.print_jobs() self.PintarFechasProxEjec() def PintarFechasProxEjec(self): for idtp in self.ListaOrdenJobs: proximaejecucion = idtp.next_run_time.strftime("%d %b %Y %H:%M:%S") texto = QtGui.QTableWidgetItem(proximaejecucion) self.MainWindow.tableWidget_TareasConfig.setItem(self.DictTareasProgramadasFilasColumnas[idtp][0],self.DictTareasProgramadasFilasColumnas[idtp][1],texto) print self.DictTareasProgramadasFilasColumnas def EjecutarQuery(self,query,params): if not params: self.BD.Insertar('exec '+str(query)) else: listapar = [] for par in params: listapar.append(par) cantidadparametros = len(params) query = 'exec '+str(query)+' ?' for arg in range(cantidadparametros-1): query = query + ' ,?' print query self.BD.Insertar(query,listapar) self.PintarFechasProxEjec() def BorrarTareaConfig(self,idtareaconfig): self.BD.Borrar('DELETE FROM t365_JobsConfig WHERE id_tareaconfig = ? ',str(idtareaconfig)) jobeliminado = self.DictTareasProgramadasByID[str(idtareaconfig)] jobeliminado.remove() del self.DictTareasProgramadasByID[str(idtareaconfig)] del self.DictTareasProgramadasFilasColumnas[jobeliminado] self.ListaOrdenJobs.remove(jobeliminado) self.CargarTareasProgramadas() self.ListarTareasProgramadas() def BorrarTareayConfigPorIDTarea(self,idtarea): tareasborrar = self.BD.Seleccionar('SELECT id_tareaconfig FROM t365_JobsConfig WHERE id_tarea = ?',str(idtarea)) for tar in tareasborrar: self.BD.Borrar('DELETE FROM t365_JobsConfig WHERE id_tareaconfig = ? ',str(tar.id_tareaconfig)) jobeliminado = self.DictTareasProgramadasByID[str(tar.id_tareaconfig)] jobeliminado.remove() del self.DictTareasProgramadasByID[str(tar.id_tareaconfig)] del self.DictTareasProgramadasFilasColumnas[jobeliminado] self.ListaOrdenJobs.remove(jobeliminado) self.CargarTareasProgramadas() self.ListarTareasProgramadas() self.BD.Borrar('DELETE FROM t365_Jobs WHERE id_tarea = ? ',str(idtarea)) def AgregarTareaProgramada(self,idtareaconfig): self.CargarTareasProgramadas() self.ListarTareasProgramadas() self.NuevaTareaProg = self.BD.Seleccionar("""SELECT t365_JobsTipos.Nombre AS nombretipo, t365_Jobs.nombre AS nombretarea, t365_JobsConfig.id_tareaconfig,t365_JobsConfig.id_tarea, t365_JobsConfig.id_tipo, t365_JobsConfig.day_run_date, t365_JobsConfig.interval_weeks, t365_JobsConfig.interval_days, t365_JobsConfig.interval_hours, t365_JobsConfig.interval_seconds, t365_JobsConfig.interval_minutes, t365_JobsConfig.start_date, t365_JobsConfig.end_date, t365_JobsConfig.cron_year, t365_JobsConfig.cron_month, t365_JobsConfig.cron_day, t365_JobsConfig.cron_week, t365_JobsConfig.cron_day_of_week, t365_JobsConfig.cron_hour, t365_JobsConfig.cron_minute, t365_JobsConfig.cron_second, t365_Jobs.query, t365_Jobs.params FROM t365_Jobs INNER JOIN t365_JobsConfig ON t365_Jobs.id_tarea = t365_JobsConfig.id_tarea INNER JOIN t365_JobsTipos ON t365_JobsConfig.id_tipo = t365_JobsTipos.id_tipo Where id_tareaconfig = ?""", str(idtareaconfig[0][0])) if self.NuevaTareaProg[0].nombretipo == 'Fecha': self.trigger = DateTrigger(run_date=self.NuevaTareaProg[0].day_run_date) self.job = self.scheduler.add_job(id=str(self.NuevaTareaProg[0].id_tareaconfig), name=self.NuevaTareaProg[0].nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args =[self.NuevaTareaProg[0].query,self.NuevaTareaProg[0].params]) elif self.NuevaTareaProg[0].nombretipo == 'Cronometro': self.trigger = CronTrigger(year=self.NuevaTareaProg[0].cron_year, month=self.NuevaTareaProg[0].cron_month, day=self.NuevaTareaProg[0].cron_day, week=self.NuevaTareaProg[0].cron_week, day_of_week=self.NuevaTareaProg[0].cron_day_of_week, hour=self.NuevaTareaProg[0].cron_hour, minute=self.NuevaTareaProg[0].cron_minute, second=self.NuevaTareaProg[0].cron_second, start_date=self.NuevaTareaProg[0].start_date, end_date=self.NuevaTareaProg[0].end_date) self.job = self.scheduler.add_job(id=str(self.NuevaTareaProg[0].id_tareaconfig), name=self.NuevaTareaProg[0].nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args =[self.NuevaTareaProg[0].query,self.NuevaTareaProg[0].params]) elif self.NuevaTareaProg[0].nombretipo == 'Interval': self.trigger = IntervalTrigger(weeks=self.NuevaTareaProg[0].interval_weeks, days=self.NuevaTareaProg[0].interval_days, hours=self.NuevaTareaProg[0].interval_hours, minutes=self.NuevaTareaProg[0].interval_minutes, seconds=self.NuevaTareaProg[0].interval_seconds, start_date=self.NuevaTareaProg[0].start_date, end_date=self.NuevaTareaProg[0].end_date) self.job = self.scheduler.add_job(id=str(self.NuevaTareaProg[0].id_tareaconfig), name=self.NuevaTareaProg[0].nombretarea, func=self.EjecutarQuery, trigger=self.trigger, args =[self.NuevaTareaProg[0].query,self.NuevaTareaProg[0].params]) self.ListaOrdenJobs.append(self.job) posicion = self.ListaOrdenJobs.index(self.job) self.DictTareasProgramadasFilasColumnas[self.job] = [posicion,2] self.DictTareasProgramadasByID[str(self.NuevaTareaProg[0].id_tareaconfig)] = self.job self.PintarFechasProxEjec()
'font-size': '12pt' } #-------------------------------- big label ######################################################################################################## ######################################################################################################## ######################################################################################################## ################ ############################ ################ THE WINDOW CLASS ############################ ################ ############################ ######################################################################################################## ######################################################################################################## ######################################################################################################## starttime = time.time() scheduler = QtScheduler() scheduler.start() class window(Ui_Xample_gui): def __init__(self, dialog_A, the_program): Ui_Xample_gui.__init__(self) self.setupUi(dialog_A) ######################################################################################################## ######################################################################################################## ######################################################################################################## ################# the first part of the class sets up the layout of the program. ##################### ################# the PLOTS are placed and the PUSH BUTTONS are connected with the ##################### ################# functions which are defined further below in the class ##################### ######################################################################################################## ########################################################################################################
class MainWindow(qtw.QMainWindow, Ui_MainWindow): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.setupUi(self) self.setWindowFlags(qtc.Qt.WindowCloseButtonHint) self.setWindowIcon(qtg.QIcon('icon.png')) # self.setWindowIcon(qtg.QIcon('./src/ressource/icon.png')) self.setFixedSize(130, 60) self.offButton.setChecked(True) self.onButton.toggled.connect(self.on_off_toggle) self.timerSpinBox.setValue(10) self.scheduler = QtScheduler() self.tray = qtw.QSystemTrayIcon(self) self.tray.setIcon(qtg.QIcon('icon.png')) # self.tray.setIcon(qtg.QIcon('./src/ressource/icon.png')) # self.tray.setIcon(qtg.QIcon(':/ressource/icon.png')) self.tray.setToolTip('BT keep Alive') quit_action = qtw.QAction("Exit", self) quit_action.triggered.connect(qtw.qApp.quit) tray_menu = qtw.QMenu() tray_menu.addAction(quit_action) self.tray.setContextMenu(tray_menu) self.tray.setVisible(True) self.tray.show() self.tray.activated.connect(self.on_systray_activated) def on_systray_activated(self, reason): if self.isVisible() and reason != qtw.QSystemTrayIcon.Context: self.hide() elif not self.isVisible() and reason != qtw.QSystemTrayIcon.Context: self.show() self.activateWindow() def closeEvent(self, event): self.hide() event.ignore() def on_off_toggle(self): if self.offButton.isChecked(): self.timerSpinBox.setEnabled(True) self.scheduler.shutdown() else: self.timerSpinBox.setEnabled(False) self.scheduler.add_job(self.play_sound, 'interval', seconds=self.timerSpinBox.value() * 60) self.scheduler.start() def play_sound(self): p = pyaudio.PyAudio() WAVEDATA = ' ' stream = p.open(format=p.get_format_from_width(1), channels=1, rate=11000, output=True) stream.write(WAVEDATA) stream.stop_stream() stream.close() p.terminate()
class EthScheduler( QtWidgets.QMainWindow, EthSchedulerGUI.Ui_EthScheduler, ): status_changed = QtCore.pyqtSignal(str, bool) def __init__(self): # access variables, methods etc in the AquetiOperationGUI.py file super(self.__class__, self).__init__() self.setupUi( self ) # This is defined in AquetiOperationGUI.py file automatically # It sets up layout and widgets that are defined print("Starting EthScheduler: current time: " + str(datetime.now().time())) print("-----------------------------------------------") print(" ") # create default save location if it doesn't exist if not os.path.exists(settings.DEFAULT_CONFIG_LOCATION): os.makedirs(settings.DEFAULT_CONFIG_LOCATION) self.workers = {} self.scheduler = QtScheduler() # fill table from file on disk self.readWorkerFile() for key, value in sorted(self.workers.items()): # add the item to the table self.addItemToTable(value['name'], value['ip'], value['username']) # start schedules for each item for key, time in sorted(value['times'].items()): self.scheduleWorker(value['name'], time['startTime'], time['endTime'], time['mode'], time['day'], time['coin'], time['address']) self.addItemToTimeTable(time['startTime'], time['endTime'], time['mode'], time['day'], time['coin'], time['address']) # setup signals and slots self.actionAdd_Worker.triggered.connect(self.addWorker) self.add_worker_pushButton.clicked.connect(self.addWorker) self.delete_worker_pushButton.clicked.connect(self.deleteWorker) self.actionQuit.triggered.connect(self.close) self.worker_tableWidget.cellClicked.connect(self.tableCellClicked) self.worker_tableWidget.cellChanged.connect(self.tableCellChanged) self.add_time_pushButton.clicked.connect(self.addTime) self.remove_time_pushButton.clicked.connect(self.removeTime) self.status_changed.connect(self.setWorkerColor) self.scheduler.start() def addItemToTimeTable(self, startTime, endTime, mode, day, coin, address): ''' add an item to the time table ''' row = self.times_tableWidget.rowCount() self.times_tableWidget.insertRow(row) self.times_tableWidget.setItem(row, 0, QtWidgets.QTableWidgetItem(startTime)) self.times_tableWidget.setItem(row, 1, QtWidgets.QTableWidgetItem(endTime)) self.times_tableWidget.setItem(row, 2, QtWidgets.QTableWidgetItem(mode)) self.times_tableWidget.setItem(row, 3, QtWidgets.QTableWidgetItem(day)) self.times_tableWidget.setItem(row, 4, QtWidgets.QTableWidgetItem(coin)) self.times_tableWidget.setItem(row, 5, QtWidgets.QTableWidgetItem(address)) self.times_tableWidget.setCurrentCell(row, 0) def addItemToTable(self, name, ip, username): ''' adds an item to the table ''' row = self.worker_tableWidget.rowCount() self.worker_tableWidget.insertRow(row) self.worker_tableWidget.setItem(row, 0, QtWidgets.QTableWidgetItem(name)) self.worker_tableWidget.setItem(row, 1, QtWidgets.QTableWidgetItem(ip)) self.worker_tableWidget.setItem(row, 2, QtWidgets.QTableWidgetItem(username)) self.worker_tableWidget.item(row, 0).setFlags(QtCore.Qt.ItemIsEnabled) self.worker_tableWidget.setCurrentCell(row, 0) def scheduleWorker(self, name, startTime, endTime, mode, day, coin, address): ''' schedules a worker ''' startTimeList = startTime.split(":") endTimeList = endTime.split(":") currentTime = datetime.now() startPulse = currentTime.replace(hour=int(startTimeList[0]), minute=int(startTimeList[1])) endTimePulse = int(endTimeList[1]) - 1 if endTimePulse > 59: endTimePulse = 1 elif endTimePulse < 1: endTimePulse = 59 endPulse = currentTime.replace(hour=int(endTimeList[0]), minute=endTimePulse) if mode == settings.SCHEDULE_DAILY: self.scheduler.add_job(self.launchWorker, 'cron', [name, coin, address], id=name + startTime + coin + 'daily', hour=startTimeList[0], minute=startTimeList[1], replace_existing=True) self.scheduler.add_job(self.stopWorker, 'cron', [name, coin, address], id=name + endTime + coin + 'daily', hour=endTimeList[0], minute=endTimeList[1], replace_existing=True) self.scheduler.add_job(self.workerPulse, 'cron', [name, coin, address], id=name + startTime + 'check' + coin + 'daily', second=30, start_date=startPulse, end_date=endPulse, replace_existing=True) print("Scheduling " + name + " to start at: " + startTime + " and end at: " + endTime + " everyday") elif mode == settings.SCHEDULE_WEEKLY: self.scheduler.add_job(self.launchWorker, 'cron', [name, coin, address], id=name + startTime + coin + "weekly", day_of_week=str(day), hour=startTimeList[0], minute=startTimeList[1], replace_existing=True) self.scheduler.add_job(self.stopWorker, 'cron', [name, coin, address], id=name + endTime + coin + "weekly", day_of_week=str(day), hour=endTimeList[0], minute=endTimeList[1], replace_existing=True) self.scheduler.add_job(self.workerPulse, 'cron', [name, coin, address], id=name + startTime + 'check' + coin + "weekly", day_of_week=str(day), second=30, start_date=startPulse, end_date=endPulse, replace_existing=True) print("Scheduling " + name + " to start at: " + startTime + " and end at: " + endTime + " on " + day) elif mode == settings.SCHEDULE_ONCE: self.scheduler.add_job(self.launchWorker, 'date', [name, coin, address], id=name + startTime + coin + "once", run_date=startPulse, replace_existing=True) self.scheduler.add_job(self.stopWorker, 'date', [name, coin, address], id=name + endTime + coin + "once", run_date=endPulse, replace_existing=True) # add pulse for interval # self.scheduler.add_job(self.workerPulse, 'cron', [name],id=name+'check', second=30, start_date=startPulse,end_date=endPulse,replace_existing=True) print("Scheduling " + name + " to start at: " + startTime + " and end at: " + endTime) def removeWorkerSchedule(self, name): ''' schedules a worker ''' # self.scheduler.remove_job(name+'start') # self.scheduler.remove_job(name+'stop') # self.scheduler.remove_job(name+'check') def tableCellClicked(self, row, column): ''' triggered when a table cell gets clicked ''' self.times_tableWidget.setRowCount(0) currentWorker = {} currentName = self.worker_tableWidget.item(row, 0).text() for key, item in self.workers.items(): if key == currentName: currentWorker = self.workers[key] for key, time in sorted(self.workers[key]['times'].items()): self.addItemToTimeTable(time['startTime'], time['endTime'], time['mode'], time['day'], time['coin'], time['address']) def tableCellChanged(self, row, column): ''' triggered when a table cell is changed ''' currentName = self.worker_tableWidget.item(row, 0).text() for key, item in self.workers.items(): if key == currentName: if (column == 1): self.workers[key]['ip'] = str( self.worker_tableWidget.item(row, column).text()) self.updateWorkerFile() # clear name tasks # schedule.clear(self.workers[key]["name"]) def updateWorkerFile(self): ''' updates a file on disk containing workers ''' target = open(settings.DEFAULT_CONFIG_LOCATION + settings.WORKER_FILE, 'w') target.write(str(self.workers)) def readWorkerFile(self): ''' read the worker file into memory ''' if os.path.isfile(settings.DEFAULT_CONFIG_LOCATION + settings.WORKER_FILE): with open(settings.DEFAULT_CONFIG_LOCATION + settings.WORKER_FILE, 'r') as f: s = f.read() self.workers = eval(s) def addTime(self): ''' add worker time ''' #append to the file on disk startTime, endTime, mode, day, coin, address, ok = EthSchedulerDialog.AddTimeDialog.addTime( self) if ok != QtWidgets.QDialog.Accepted: return self.addItemToTimeTable(startTime, endTime, mode, day, coin, address) currentRow = self.worker_tableWidget.currentRow() currentName = self.worker_tableWidget.item(currentRow, 0).text() time = {} time['startTime'] = str(startTime) time['endTime'] = str(endTime) time['mode'] = str(mode) time['day'] = str(day) time['coin'] = str(coin) time['address'] = str(address) self.workers[currentName]['times'][time['startTime'] + time['endTime']] = time self.updateWorkerFile() self.scheduleWorker(currentName, time['startTime'], time['endTime'], time['mode'], time['day'], time['coin'], time['address']) def removeTime(self): ''' remove worker time ''' currentRow = self.worker_tableWidget.currentRow() currentName = self.worker_tableWidget.item(currentRow, 0).text() currentTimeRow = self.times_tableWidget.currentRow() currentTimeStart = self.times_tableWidget.item(currentTimeRow, 0).text() currentTimeEnd = self.times_tableWidget.item(currentTimeRow, 1).text() del self.workers[currentName]['times'][currentTimeStart + currentTimeEnd] self.updateWorkerFile() self.times_tableWidget.removeRow(currentTimeRow) self.removeWorkerSchedule(currentName) def exists_remote(self, host, path): """Test if a file exists at path on a host accessible with SSH.""" status = subprocess.call( ['ssh', host, 'test -f {}'.format(pipes.quote(path))]) print(status) if status == 0: return True if status == 1: return False raise Exception('SSH failed') def setupWorker(self, ip, username): ''' setup the specified worker for mining ''' if not self.exists_remote(username + '@' + ip, ' ~/.eth/ '): self.runRemoteProcess(ip, username, 'mkdir ~/.eth/ ') dir_path = os.path.dirname(os.path.realpath(__file__)) copyProcesses = subprocess.Popen([ "scp", "-rp", dir_path + "/miners", "%s@%s:~/.eth/" % (username, ip) ]) def addWorker(self): ''' add a worker to the interface ''' worker = {} username, ip, name, ok = EthSchedulerDialog.AddWorkerDialog.addWorker( self) if ok != QtWidgets.QDialog.Accepted: return # setup the worker for mining self.setupWorker(ip, username) # add worker to the next line in the table self.addItemToTable(name, ip, username) worker['username'] = str(username) worker['name'] = str(name) worker['ip'] = str(ip) worker['status'] = 'IDLE' worker['times'] = {} self.workers[str(name)] = worker #append to the file on disk self.updateWorkerFile() def deleteWorker(self): ''' remove a worker from the interface ''' currentRow = self.worker_tableWidget.currentRow() currentName = self.worker_tableWidget.item(currentRow, 0).text() toRemove = {} for key, item in self.workers.items(): if key == currentName: del self.workers[key] self.updateWorkerFile() self.worker_tableWidget.removeRow(currentRow) self.removeWorkerSchedule(currentName) if os.access('~/.eth/miners', os.R_OK): self.runRemoteProcess(currentName['ip'], currentName['username'], 'rm -r ~/.eth/miners') def checkWorker(self, name, coin): ''' checks the system for running ethminer ''' CHECK = "ps cax | grep " + coin currentWorker = {} for key, item in self.workers.items(): if key == name: currentWorker = self.workers[key] checkProcesses = subprocess.Popen([ "ssh", "%s@%s" % (currentWorker['username'], currentWorker['ip']), CHECK ], stdout=subprocess.PIPE, shell=False, stderr=subprocess.PIPE) checkStdout = checkProcesses.stdout.readlines() for process in checkStdout[:]: if coin in str(process)[:]: # self.setWorkerColor(name,True) self.status_changed.emit(name, True) return True # self.setWorkerColor(name,False) self.status_changed.emit(name, False) return False def setWorkerColor(self, name, enable): ''' ''' for row in range(self.worker_tableWidget.rowCount()): currentName = self.worker_tableWidget.item(row, 0).text() if currentName == name: if enable: self.worker_tableWidget.item(row, 0).setBackground( settings.GREEN) else: self.worker_tableWidget.item(row, 0).setBackground( settings.YELLOW) def workerPulse(self, name, coin, address): ''' checks worker and restarts if not found ''' rc = self.checkWorker(name, coin) if not rc: print("Unable to detect: " + name + " Restarting: " + str(datetime.now().time())) self.launchWorker(name, coin, address) else: print(name + " was found: " + str(datetime.now().time())) def launchWorker(self, name, coin, address): ''' starts the specified worker ''' currentWorker = {} print("Starting: " + name + " Time is: " + str(datetime.now().time())) # self.setWorkerColor(name,True) self.status_changed.emit(name, True) for key, item in self.workers.items(): if key == name: currentWorker = self.workers[key] cmd = [] if coin == settings.ETHERIUM: cmd.append("~/.eth/miners/ethminer") cmd.append('--farm-recheck') cmd.append('400') cmd.append('--cl-global-work') cmd.append('16384') cmd.append('-G') cmd.append('-RH') cmd.append('-S') cmd.append('us1.ethermine.org:4444') cmd.append('-FS') cmd.append('us1.ethermine.org:14444') cmd.append('-O') cmd.append(str(address) + '.' + name) elif coin == settings.MONERO: #./minerd -a cryptonight -o stratum+tcp://mine.moneropool.com:3333 -u ADDRESS -p x cmd.append('~/.eth/miners/minerd') cmd.append('-a') cmd.append('cryptonight') cmd.append('-o') cmd.append('stratum+tcp://xmr.crypto-pool.fr:3333') cmd.append('-u') cmd.append(str(address)) cmd.append('-p') cmd.append('x') cmd.extend(['>>', '~/.eth/log.txt', '2>&1']) # print(' '.join(cmd)) self.runRemoteProcess(currentWorker['ip'], currentWorker['username'], ' '.join(cmd)) currentWorker['status'] = 'WORKING' def stopWorker(self, name, coin, address): ''' stops the specified worker ''' currentWorker = {} print("Stopping: " + name + " Time is: " + str(datetime.now().time())) # self.setWorkerColor(name,False) self.status_changed.emit(name, False) for key, item in self.workers.items(): if key == name: currentWorker = self.workers[key] cmd = ["pkill"] cmd.append('-15') if coin == settings.ETHERIUM: cmd.append('ethminer') elif coin == settings.MONERO: cmd.append('minerd') self.runRemoteProcess(currentWorker['ip'], currentWorker['username'], ' '.join(cmd)) if os.access('~/.eth/log.txt', os.R_OK): self.runRemoteProcess(currentWorker['ip'], currentWorker['username'], 'rm ~/.eth/log.txt') currentWorker['status'] = 'IDLE' def runRemoteProcess(self, ip, username, cmd): ''' runs Acos on all the tegras ''' runRemoteProcess = subprocess.Popen( ["ssh", "%s@%s" % (username, ip), cmd]) def closeEvent(self, event): ''' catches the close event ''' reply = QtWidgets.QMessageBox.question( self, 'Shutdown', "Are you sure you want to quit?", QtWidgets.QMessageBox.Yes, QtWidgets.QMessageBox.No) if reply == QtWidgets.QMessageBox.Yes: self.shutdown() else: event.ignore() def shutdown(self): ''' shuts down the GUI ''' # stop all workers? for key, value in self.workers.items(): for key, time in sorted(value['times'].items()): self.stopWorker(value['name'], time['coin'], time['address']) self.close()
class laser_control(object): def __init__(self): #---------------------------------------------------------------------# #--- GLOBAL PARAMETERS AND VARIABLES ---------------------------------# #---------------------------------------------------------------------# #--- FREQUENCY Parameters --------------------------------------------# self.nu_blue_1_was, self.nu_blue_2_was, self.nu_red_1_was, self.nu_red_2_was = [ 0 ] * 500, [0] * 500, [0] * 500, [0] * 500 self.nu_history = { 'blue_1': [0] * 500, 'blue_2': [0] * 500, 'red_1': [0] * 500, 'red_2': [0] * 500, '423': [0] * 500 } self.nu_blue_1_is, self.nu_blue_2_is, self.nu_red_1_is, self.nu_red_2_is = 0.0, 0.0, 0.0, 0.0 self.nu = {'blue_1': 0, 'blue_2': 0, 'red_1': 0, 'red_2': 0, '423': 0} self.nu_prev = self.nu.copy() self.nu_blue_1_want, self.nu_blue_2_want, self.nu_red_1_want, self.nu_red_2_want = 755.186770, 0.0, 0.0, 0.0 self.nu_setpoint = self.nu.copy() self.nu_blue_1_smooth_flag, self.nu_blue_2_smooth_flag, self.nu_red_1_smooth_flag, self.nu_red_2_smooth_flag = 1, 1, 1, 1 self.nu_blue_1_smooth_want, self.nu_blue_2_smooth_want, self.nu_red_1_smooth_want, self.nu_red_2_smooth_want = 755.186770, 0.0, 0.0, 0.0 self.nu_blue_1_smooth_delta_t, self.nu_blue_2_smooth_delta_t, self.nu_red_1_smooth_delta_t, self.nu_red_2_smooth_delta_t = 10.0, 10.0, 10.0, 10.0 self.nu_smooth_increment = 0.000001 #---------------------------------------------------------------------# #--- PIEZO Parameters ------------------------------------------------# self.nu_blue_1_piezo_set, self.nu_blue_2_piezo_set, self.nu_red_1_piezo_set, self.nu_red_2_piezo_set = 0.0, 0.0, 0.0, 0.0 #---------------------------------------------------------------------# #--- LOCKING Parameters ----------------------------------------------# self.lock_blue_1 = False self.lock_lasers = { 'blue_1': False, 'blue_2': False, 'red_1': False, 'red_2': False, '423': False } self.lock_blue_2_flag, self.lock_red_1_flag, self.lock_red_2_flag = 1, 1, 1 self.lock_blue_1_alpha, self.lock_blue_2_alpha, self.lock_red_1_alpha, self.lock_red_2_alpha = 20., 20., 20., 20. self.lock_blue_1_beta, self.lock_blue_2_beta, self.lock_red_1_beta, self.lock_red_2_beta = 15., 15., 15., 15. default_lock_pars = {'k_p': 20, 'k_i': 20} self.lock_pars = { 'blue_1': default_lock_pars.copy(), 'blue_2': default_lock_pars.copy(), 'red_1': default_lock_pars.copy(), 'red_2': default_lock_pars.copy(), '423': default_lock_pars.copy() } self.lock_blue_1_Integral, self.lock_blue_2_Integral, self.lock_red_1_Integral, self.lock_red_2_Integral = 0.0, 0.0, 0.0, 0.0 self.errors_previous = { 'blue_1': 0, 'blue_2': 0, 'red_1': 0, 'red_2': 0, '423': 0 } self.lock_polarity = {'blue_1': +1, 'blue_2': +1, '423': -1} #Lock error counters self.lock_blue_1_count, self.lock_blue_2_count, self.lock_red_1_count, self.lock_red_2_count = 0, 0, 0, 0 self.lock_count = { 'blue_1': 0, 'blue_2': 0, 'red_1': 0, 'red_2': 0, '423': 0 } #---------------------------------------------------------------------# #--- SAWTOOTH Parameters ---------------------------------------------# self.sawtooth_flag = 1 self.sawtooth_nu_blue_1_init = 755.186880 self.sawtooth_nu_blue_1_detuned = 755.186780 self.sawtooth_nu_blue_2_init = 755.258220 self.sawtooth_nu_blue_2_detuned = 755.258120 self.sawtooth_delta_t1 = 1.5 self.sawtooth_delta_t2 = 0.75 self.sawtooth_t_incr = 0.05 self.sawtooth_total_reps = 1 self.sawtooth_t_total = [] self.sawtooth_nu1_total = [] self.sawtooth_nu2_total = [] #---------------------------------------------------------------------# #--- Debug vars ------------------------------------------------------# self.debug_flag = False self.debug_number = 10 #---------------------------------------------------------------------# #---------------------------------------------------------------------# #---------------------------------------------------------------------# #---------------------------------------------------------------------# #--- CREATE INSTANCES OF WM AND LASER CONTROLLERS --------------------# #---------------------------------------------------------------------# #---------------------------------------------------------------------# self.HF_WM = HighFinesse_WM() #---------------------------------------------------------------------# #---------------------------------------------------------------------# self.T_DLC_blues = Toptica_DLC_pro('192.168.0.2') self.lock_blue_1_piezo_volt_set = float( self.T_DLC_blues.read_parameter('laser1:dl:pc:voltage-set')) self.lock_blue_2_piezo_volt_set = float( self.T_DLC_blues.read_parameter('laser2:dl:pc:voltage-set')) #---------------------------------------------------------------------# self.lock_blue_1_piezo_volt_init = self.lock_blue_1_piezo_volt_set self.lock_blue_2_piezo_volt_init = self.lock_blue_2_piezo_volt_set #---------------------------------------------------------------------# self.T_DLC_reds = Toptica_DLC_pro('192.168.0.3') self.lock_red_1_piezo_volt_set = float( self.T_DLC_reds.read_parameter('laser1:dl:pc:voltage-set')) self.lock_red_2_piezo_volt_set = float( self.T_DLC_reds.read_parameter('laser2:dl:pc:voltage-set')) #---------------------------------------------------------------------# self.lock_red_1_piezo_volt_init = self.lock_red_1_piezo_volt_set self.lock_red_2_piezo_volt_init = self.lock_red_2_piezo_volt_set self.DAQ_423 = DAQ() #DAQ_voltage = DAQ_423.get_voltage(5) DAQ_voltage = 0 self.piezo_volt = { 'blue_1': self.lock_blue_1_piezo_volt_set, 'blue_2': self.lock_blue_2_piezo_volt_set, 'red_1': self.lock_red_1_piezo_volt_set, 'red_2': self.lock_red_2_piezo_volt_set, '423': DAQ_voltage } #---------------------------------------------------------------------# #---------------------------------------------------------------------# #---------------------------------------------------------------------# #---------------------------------------------------------------------# #--- SCHEDULE ITERATIVE JOBS TO GET DATA FROM WM ---------------------# #---------------------------------------------------------------------# #---------------------------------------------------------------------# self.program_scheduler = QtScheduler() self.program_scheduler.start() #---------------------------------------------------------------------# #---------------------------------------------------------------------# self.program_scheduler.add_job(self.control_loop, 'interval', seconds=0.05, id='id_update_wm_data') #---------------------------------------------------------------------# #---------------------------------------------------------------------# #---------------------------------------------------------------------# #---------------------------------------------------------------------# ########################################################################### ########################################################################### ### THE FUNCTIONS BASED ON THE TWO OBJECTS WM AND TLC ##################### ########################################################################### ########################################################################### #-- MAIN CONTROL LOOP ----------------------------------------------------# def control_loop(self): self.get_data_HF_WM() if self.lock_lasers['blue_1']: self.lock_laser('blue_1') if self.lock_lasers['blue_2']: self.lock_laser('blue_2') if self.lock_lasers['423']: self.lock_laser('423') ########################################################################### ### FUNCTION TO GET THE WAVEMETER DATA #################################### ########################################################################### #--- get the data for the WS8 wavemeter ----------------------------------# def get_data_HF_WM(self): ''' reads the frequencies on the four wavemeter channels 1,2,3,4. transforms them from THz to 100kHz (integers) and back to THz appends the values to a list to monitor the time dependence of the frequency ''' self.nu_red_1_is = int(self.HF_WM.get_frequency(3) * 10**7) / 10**7 self.nu_red_2_is = int(self.HF_WM.get_frequency(4) * 10**7) / 10**7 self.nu['blue_1'] = self.HF_WM.get_frequency(1) self.nu['blue_2'] = self.HF_WM.get_frequency(2) self.nu['423'] = self.HF_WM.get_frequency(5) self.nu_history['blue_1'].append(self.nu['blue_1']) self.nu_history['blue_2'].append(self.nu['blue_2']) self.nu_history['423'].append(self.nu['423']) self.nu_blue_1_was.append(self.nu_blue_1_is) self.nu_blue_2_was.append(self.nu_blue_2_is) self.nu_red_1_was.append(self.nu_red_1_is) self.nu_red_2_was.append(self.nu_red_2_is) #-------------------------------------------------------------------------# ########################################################################### ########################################################################### ########################################################################### ########################################################################### ### FUNCTIONS FOR LASER BLUE 1 ############################################ ########################################################################### #--- function to lock laser ---------------------------------------# def lock_laser_setup(self, laser_id): if laser_id == '423': self.debug_flag = False self.debug_counter = 0 self.errors_previous[laser_id] = 0.0 def lock_laser(self, laser_id): ''' a PI controller is implemented, with gains alpha for the proportional and beta for the integral part. the if statement at the end ensures that there are no big jumps in the piezo voltage, which might be applied otherwise if there is mode jumping in the laser. for too big voltage jumps the lock breaks. ''' nu_is = self.nu[laser_id] nu_wanted = self.nu_setpoint[laser_id] error = nu_wanted - nu_is error_previous = self.errors_previous[laser_id] self.errors_previous[laser_id] = error k_p = self.lock_pars[laser_id]['k_p'] k_i = self.lock_pars[laser_id]['k_i'] polarity = self.lock_polarity[laser_id] #------------------------------------------------# # proportional part -----------------------------# P_part = polarity * k_p * (error - error_previous) #------------------------------------------------# # integral part ---------------------------------# I_part = polarity * k_i * error #------------------------------------------------# # prop + in + current set voltage ---------------# new_piezo_value = P_part + I_part + self.piezo_volt[laser_id] #------------------------------------------------# # debug information -----------------------------# if laser_id == '423': # restricted to blue 2 for now if self.debug_flag: if self.debug_counter == 0: self.t0 = time.monotonic() print(f'initial nu: {nu_is}') print( f'initial piezo value: {self.lock_blue_2_piezo_volt_set}' ) print(f'k_p: {k_p}, k_i: {k_i}') self.summed_ms_error = 0.0 self.debug_counter = 1 self.errors = np.zeros( self.debug_number ) # this will cause issues if self.debug_number is updated during debugging... elif self.debug_counter <= self.debug_number: print( f'time: {(time.monotonic()-self.t0):.2}, nu: {nu_is}, error: {error*1e6:.8}MHz' ) print( f' prop: {P_part:.8}, int: {I_part:.8}, new pzt value: {new_piezo_value:.8}' ) self.errors[self.debug_counter - 1] = error self.summed_ms_error += error**2 self.debug_counter += 1 else: rmserror = np.sqrt(self.summed_ms_error / self.debug_counter) print(f'rms error: {rmserror*1e6} MHz') stddev = np.std(self.errors) print(f'std error: {stddev*1e6} MHz') self.debug_flag = False self.debug_counter = 0 # restrict voltage jumps if -1 <= (P_part + I_part) <= 1: if laser_id is '423': if -1 < new_piezo_value < 1: pass else: print( f'break lock for laser {laser_id}, scan voltage mod too large!' ) self.lock_lasers[laser_id] = False self.lock_count[laser_id] = 0 return self.set_piezo(new_piezo_value, laser_id) self.piezo_volt[laser_id] = new_piezo_value self.lock_count[laser_id] = 0 else: if self.lock_count[laser_id] < 10: self.lock_count[laser_id] += 1 pass else: print( f'break lock for laser {laser_id}, delta in piezo voltage too large!' ) self.lock_lasers[laser_id] = False self.lock_count[laser_id] = 0 #-------------------------------------------------------------------------# def set_piezo(self, piezo_value, laser_id): if laser_id == 'blue_1': self.T_DLC_blues.set_parameter('laser1:dl:pc:voltage-set', piezo_value) elif laser_id == 'blue_2': self.T_DLC_blues.set_parameter('laser2:dl:pc:voltage-set', piezo_value) elif laser_id == '423': self.DAQ_423.set_voltage(5, piezo_value) def lock_laser_on(self, laser_id): if not self.lock_lasers[laser_id]: self.lock_laser_setup(laser_id) self.lock_lasers[laser_id] = True print(f'Lock for laser {laser_id} turned ON') else: print(f'{laser_id} lock already engaged') def lock_laser_off(self, laser_id): print(f'Lock for laser {laser_id} turned OFF') self.lock_lasers[laser_id] = False #-------------------------------------------------------------------------# ########################################################################### ### FUNCTIONS FOR LASER RED 1 ############################################# ########################################################################### #--- function to lock laser red 1 ----------------------------------------# def f_lock_laser_red_1(self): ''' for explanation see same function for laser blue 1 ''' while self.lock_red_1_flag == 0: # copy parameters to be fixed for this iteration # nu_is = self.nu_red_1_is nu_wanted = self.nu_red_1_want nu_error = nu_wanted - nu_is alpha = self.lock_red_1_alpha beta = self.lock_red_1_beta #------------------------------------------------# # proportional part -----------------------------# P_part = alpha * nu_error #------------------------------------------------# # integral part ---------------------------------# I_part = beta * self.lock_red_1_Integral self.lock_red_1_Integral += nu_error #------------------------------------------------# # prop + in + current set voltage ---------------# PI = P_part + I_part + self.lock_red_1_piezo_volt_set #------------------------------------------------# # sleep time - to be synchronized with data gathering from wm # time.sleep(0.05) #------------------------------------------------# # restrict voltage jumps NEEDS TO BE DONE MORE CLEVER! if self.lock_red_1_piezo_volt_init - 5 <= PI <= self.lock_red_1_piezo_volt_init + 5: self.T_DLC_reds.set_parameter('laser1:dl:pc:voltage-set', PI) self.lock_red_1_piezo_volt_set = PI self.lock_red_1_count = 0 else: if self.lock_red_1_count < 10: self.lock_red_1_count += 1 pass else: print( 'break lock for laser red 1, delta in piezo voltage too large!' ) self.lock_red_1_flag = 1 self.lock_red_1_count = 0 #-------------------------------------------------------------------------# #--- start thread calling function to lock laser blue 1 ------------------# def lock_laser_red_1_on(self): ''' for explanation see same function for laser blue 1 ''' print('lock laser red 1 turned ON') self.lock_red_1_flag = 0 thread_lock_red_1 = threading.Thread(target=self.f_lock_laser_red_1) thread_lock_red_1.start() #-------------------------------------------------------------------------# #--- stop thread calling function to lock laser blue 1 -------------------# def lock_laser_red_1_off(self): ''' for explanation see same function for laser blue 1 ''' print('lock laser red 1 turned OFF') self.lock_red_1_flag = 1 #-------------------------------------------------------------------------# #--- function to smoothley detune laser blue 1 ---------------------------# def f_smooth_change_laser_red_1(self): ''' for explanation see same function for laser blue 1 ''' nu_start_MHz = int(self.nu_red_1_is * 10**6) nu_stop_MHz = int(self.nu_red_1_smooth_want * 10**6) nu_incr_MHz = int(self.nu_smooth_increment * 10**6) delta_t = self.nu_red_1_smooth_delta_t if nu_start_MHz < nu_stop_MHz: nu_list_MHz = np.arange(nu_start_MHz + nu_incr_MHz, nu_stop_MHz + nu_incr_MHz, nu_incr_MHz) elif nu_start_MHz > nu_stop_MHz: nu_list_MHz = np.arange(nu_stop_MHz, nu_start_MHz + nu_incr_MHz, nu_incr_MHz) nu_list_MHz = nu_list_MHz[::-1] nu_list = nu_list_MHz / 10**6 t_increment = delta_t / float(len(nu_list)) for i in range(len(nu_list)): if self.nu_red_1_smooth_flag == 0: self.nu_red_1_want = nu_list[i] time.sleep(t_increment) else: break #-------------------------------------------------------------------------# #--- start thread calling function to smoothley detune laser blue 1 ------# def smooth_change_laser_red_1_start(self): ''' for explanation see same function for laser blue 1 ''' print('smooth change laser red 1 STARTED') self.nu_red_1_smooth_flag = 0 thread_smooth_change_red_1 = threading.Thread( target=self.f_smooth_change_laser_red_1) thread_smooth_change_red_1.start() #-------------------------------------------------------------------------# #--- start thread calling function to smoothley detune laser blue 1 ------# def smooth_change_laser_red_1_stop(self): ''' for explanation see same function for laser blue 1 ''' print('smooth change laser red 1 STOPPED') self.nu_red_1_smooth_flag = 1 #-------------------------------------------------------------------------# ########################################################################### ########################################################################### ########################################################################### ########################################################################### ### FUNCTIONS FOR LASER RED 2 ############################################# ########################################################################### #--- function to lock laser red 1 ----------------------------------------# def f_lock_laser_red_2(self): ''' for explanation see same function for laser blue 1 ''' while self.lock_red_2_flag == 0: # copy parameters to be fixed for this iteration # nu_is = self.nu_red_2_is nu_wanted = self.nu_red_2_want nu_error = nu_wanted - nu_is alpha = self.lock_red_2_alpha beta = self.lock_red_2_beta #------------------------------------------------# # proportional part -----------------------------# P_part = alpha * nu_error #------------------------------------------------# # integral part ---------------------------------# I_part = beta * self.lock_red_2_Integral self.lock_red_2_Integral += nu_error #------------------------------------------------# # prop + in + current set voltage ---------------# PI = P_part + I_part + self.lock_red_2_piezo_volt_set #------------------------------------------------# # sleep time - to be synchronized with data gathering from wm # time.sleep(0.05) #------------------------------------------------# # restrict voltage jumps NEEDS TO BE DONE MORE CLEVER! if self.lock_red_2_piezo_volt_init - 5 <= PI <= self.lock_red_2_piezo_volt_init + 5: self.T_DLC_reds.set_parameter('laser2:dl:pc:voltage-set', PI) self.lock_red_2_piezo_volt_set = PI self.lock_red_2_count = 0 else: if self.lock_red_2_count < 10: self.lock_red_2_count += 1 pass else: print( 'break lock for laser red 2, delta in piezo voltage too large!' ) self.lock_red_2_flag = 1 self.lock_red_2_count = 0 #-------------------------------------------------------------------------# #--- start thread calling function to lock laser blue 1 ------------------# def lock_laser_red_2_on(self): ''' for explanation see same function for laser blue 1 ''' print('lock laser red 2 turned ON') self.lock_red_2_flag = 0 thread_lock_red_2 = threading.Thread(target=self.f_lock_laser_red_2) thread_lock_red_2.start() #-------------------------------------------------------------------------# #--- stop thread calling function to lock laser blue 1 -------------------# def lock_laser_red_2_off(self): ''' for explanation see same function for laser blue 1 ''' print('lock laser red 2 turned OFF') self.lock_red_2_flag = 1 #-------------------------------------------------------------------------# #--- function to smoothley detune laser blue 1 ---------------------------# def f_smooth_change_laser_red_2(self): ''' for explanation see same function for laser blue 1 ''' nu_start_MHz = int(self.nu_red_2_is * 10**6) nu_stop_MHz = int(self.nu_red_2_smooth_want * 10**6) nu_incr_MHz = int(self.nu_smooth_increment * 10**6) delta_t = self.nu_red_2_smooth_delta_t if nu_start_MHz < nu_stop_MHz: nu_list_MHz = np.arange(nu_start_MHz + nu_incr_MHz, nu_stop_MHz + nu_incr_MHz, nu_incr_MHz) elif nu_start_MHz > nu_stop_MHz: nu_list_MHz = np.arange(nu_stop_MHz, nu_start_MHz + nu_incr_MHz, nu_incr_MHz) nu_list_MHz = nu_list_MHz[::-1] nu_list = nu_list_MHz / 10**6 t_increment = delta_t / float(len(nu_list)) for i in range(len(nu_list)): if self.nu_red_2_smooth_flag == 0: self.nu_red_2_want = nu_list[i] time.sleep(t_increment) else: break #-------------------------------------------------------------------------# #--- start thread calling function to smoothley detune laser blue 1 ------# def smooth_change_laser_red_2_start(self): ''' for explanation see same function for laser blue 1 ''' print('smooth change laser red 2 STARTED') self.nu_red_2_smooth_flag = 0 thread_smooth_change_red_2 = threading.Thread( target=self.f_smooth_change_laser_red_2) thread_smooth_change_red_2.start() #-------------------------------------------------------------------------# #--- start thread calling function to smoothley detune laser blue 1 ------# def smooth_change_laser_red_2_stop(self): ''' for explanation see same function for laser blue 1 ''' print('smooth change laser red 2 STOPPED') self.nu_red_2_smooth_flag = 1
class App(QtWidgets.QMainWindow): def __init__(self): super(App, self).__init__() # Call the class generated by the .ui file # from QT Designer. self.ui = Ui_window() self.ui.setupUi(self) # Make window frameless. self.setWindowFlags(QtCore.Qt.FramelessWindowHint) self.months = [ 'Jan', 'Feb', 'Mar', 'Apr', 'May', ' Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec' ] self.weekdays = [ 'Monday', 'Tuesdag', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday' ] self.direction = { '\u2191': [330, 30], # N '\u2196': [310, 320], # NW '\u2190': [240, 300], # W '\u2199': [200, 230], # SW '\u2193': [150, 190], # S '\u2198': [130, 140], # SE '\u2192': [60, 120], # E '\u2197': [40, 50] } # NE self.scheduler = QtScheduler() self.set_time() self.set_weather() self.schedule() self.show() def mousePressEvent(self, event): # Function that gets called from parent object # when a mouse press is detected. if event.buttons() == QtCore.Qt.LeftButton or event.buttons( ) == QtCore.Qt.RightButton: self.dragPos = event.globalPos() event.accept() def mouseMoveEvent(self, event): # Function that gets called from parent object # when mouse movement is detected. if event.buttons() == QtCore.Qt.LeftButton or event.buttons( ) == QtCore.Qt.RightButton: if not self.ui.pin.isChecked(): self.move(self.pos() + event.globalPos() - self.dragPos) self.dragPos = event.globalPos() event.accept() def schedule(self): # Schedule functions to run at certain intervals. self.scheduler.add_job(self.set_weather, trigger=interval.IntervalTrigger(minutes=15)) self.scheduler.add_job(self.set_time, trigger=interval.IntervalTrigger(seconds=1)) self.scheduler.start() def set_time(self): # Update the window with the current time. now = datetime.now() date = datetime.today() self.ui.time.setText(now.strftime('%H:%M:%S')) self.ui.day.setText(self.weekdays[datetime.today().weekday()]) self.ui.date.setText( f'{self.months[date.month - 1]}. {str(date.day)}. {str(date.year)[:2]}.' ) def set_weather(self): try: # Get the latitude and longitude of current IP and # then get the weather for said location. # Note that an api_key from openweathermap.org needs # to be provided. lat, lon = latlon('me') weather = current_weather(api_key='#', lat=lat, lon=lon) # Find the corresponding image to the weather description. weathericon = QtGui.QPixmap('images/' + weather['weather'][0]['icon'] + '.png') weathericon = weathericon.scaled(50, 50) # Find the corresponding arrow symbol to the wind direction. for di in self.direction: if di != '\u2191': if self.direction[di][0] <= weather['wind'][ 'deg'] <= self.direction[di][1]: direction = di else: if weather['wind']['deg'] > self.direction[di][0] or \ weather['wind']['deg'] < self.direction[di][1]: direction = di # Update the window with the new data. self.ui.weathericon.setPixmap(weathericon) self.ui.description.setText(weather['weather'][0]['description']) self.ui.temp.setText( str(round(weather['main']['temp'] - 273.15, 1)) + u'\u2103') self.ui.wind.setText(direction + ' ' + str(weather['wind']['speed']) + ' m/s') self.ui.humidity.setText( str(weather['main']['humidity']) + '% Humidity') except TypeError: # This will be raised if there is no internet connection. pass
else: pass except Exception as ex: logger.critical(str(ex)) player.play() scheduler = QtScheduler() scheduler.add_job( checkUnreadEmail, "interval", seconds=INTERVAL, args=[GROUP_FOLDER, TARGET_FOLDER, mediaPlayer, logger], ) scheduler.start(paused=True) def runClicked(scheduler, runBtn, stopBtn, stopSoundBtn): runBtn.setEnabled(False) stopBtn.setEnabled(True) stopSoundBtn.setEnabled(True) scheduler.resume() def stopClicked(scheduler, runBtn, stopBtn, stopSoundBtn): runBtn.setEnabled(True) stopBtn.setEnabled(False) stopSoundBtn.setEnabled(False) scheduler.pause()
class PsKiller(QtGui.QWidget): def __init__(self): """docstring for __init__""" super(PsKiller, self).__init__() self.init_ui() self.updateTableSignal = UpdateTableSignal() self.updateTableSignal.updateTable.connect(lambda: self.refresh_list(self.search_edit.text())) self.scheduler = QtScheduler() self.scheduler.add_job(self.update_table_emitter, "interval", seconds=2) self.scheduler.start() def init_ui(self): """docstring for init_ui""" self.pid_edit = QtGui.QLineEdit() kill_btn = QtGui.QPushButton("Kill Me", self) kill_btn.clicked.connect(self.kill_ps) self.header = ["PID", "Process Name", "Absolute Path", "Command Line"] self.table_view = ListTableView() self.table_view.setModel(PsInfoModel(self.get_ps_info(""), self.header, self)) self.table_view.clicked.connect(self.cell_click) self.table_view.setMouseTracking(True) self.table_view.entered.connect(self.show_cell_content) self.table_view.verticalHeader().setVisible(False) self.table_view.setColumnWidth(2, 300) self.table_view.setColumnWidth(3, 300) self.search_edit = SearchBox() self.search_edit.keyPressed.connect(self.search_by_keyword) self.status_bar = QtGui.QStatusBar() self.status_bar.showMessage("ready") grid = QtGui.QGridLayout() grid.setSpacing(10) grid.addWidget(self.pid_edit, 1, 0) grid.addWidget(kill_btn, 1, 1) grid.addWidget(self.search_edit, 2, 0) grid.addWidget(self.table_view, 3, 0, 5, 2) grid.addWidget(self.status_bar, 9, 0) self.setLayout(grid) self.setWindowTitle("PS Killer") self.setGeometry(300, 300, 300, 150) self.resize(800, 400) self.show() def update_table_emitter(self): self.updateTableSignal.updateTable.emit() def refresh_list(self, keyword=""): self.table_view.setModel(PsInfoModel(self.get_ps_info(keyword), self.header, self)) def get_ps_info(self, keyword): pinfo_arr = [] for proc in psutil.process_iter(): try: pinfo = proc.as_dict(attrs=["pid", "name", "exe", "cmdline"]) except psutil.NoSuchProcess: pass else: if keyword == "": pinfo_arr.append(pinfo) else: if ( re.search(str(keyword).lower(), pinfo["name"].lower()) != None or re.search(str(keyword).lower(), str(pinfo["exe"]).lower()) != None or ( pinfo["cmdline"] != None and re.search(str(keyword).lower(), " ".join(pinfo["cmdline"]).lower()) != None ) ): pinfo_arr.append(pinfo) return pinfo_arr def search_by_keyword(self): """docstring for search_by_keyword""" keyword = self.search_edit.text() if keyword != "": self.refresh_list(keyword) else: self.refresh_list() def kill_ps(self): """docstring for kill_ps""" pid = self.pid_edit.text() try: pid = int(pid) process = psutil.Process(pid) for child in process.children(recursive=True): child.kill() process.kill() self.status_bar.showMessage("Process " + str(pid) + " is killed") except psutil.NoSuchProcess: self.status_bar.showMessage("Process " + str(pid) + " is not exist") except psutil.AccessDenied: self.status_bar.showMessage("Unable kill process " + str(pid) + ".Must be a root user.") except ValueError: self.status_bar.showMessage("Process " + str(pid) + " is an invalidated pid.") def closeEvent(self, event): self.scheduler.shutdown() def cell_click(self, item): cell_content = item.data() selected_val = cell_content.toPyObject() if isinstance(selected_val, int): self.pid_edit.setText(str(selected_val)) else: self.status_bar.showMessage(selected_val + " is invalid!") def show_cell_content(self, item): """docstring for show_cell_content""" current_value = item.data().toPyObject() if current_value != None: self.status_bar.showMessage(str(current_value))