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
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)
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()
import sys
import itchat
from PyQt5.QtWidgets import *
from apscheduler.schedulers.qt import QtScheduler
itchat.auto_login(hotReload=False)
chat_rooms = itchat.get_chatrooms()
def SentChatRoomsMsg(name, context):
f = itchat.search_friends(name='沈姐姐')
r = itchat.send_msg('大家好', f[0]['UserName'])
print(r)
app = QApplication([])
w1 = QWidget()
w2 = QWidget()
w1.show()
w2.show()
scheduler = QtScheduler()
scheduler.start()
scheduler.add_job(SentChatRoomsMsg,
kwargs={"name": 'oooo', "context": 'kkkkk'})
print('结束')
code = app.exec()
sys.exit(code)
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"]
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 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 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
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 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()
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 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)
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 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
if unreadEmails.Count > 0:
if player.state() != QMediaPlayer.PlayingState:
player.play()
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)
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))
