def add(self, url: QUrl, position: int = -1) -> bool:
if not url.isValid():
return False
media_info = MediaInfo.parse(url.toLocalFile())
track = media_info.tracks[0]
if track.title is None:
title = url.fileName()
else:
title = track.title
if track.duration is None:
duration_str = '--:--'
else:
duration = int(float(track.duration) / 1000)
totalTime = QTime((duration / 3600) % 60, (duration / 60) % 60,
(duration % 60), (duration * 1000) % 1000)
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
duration_str = totalTime.toString(format)
if position >= self.rowCount() or position < 0:
position = self.rowCount()
self.beginInsertRows(QModelIndex(), position, position + 1)
media_info = {'url': url, 'title': title, 'duration': duration_str}
self.item_list.insert(position, media_info)
self.endInsertRows()
self.rowCount_changed.emit(self.rowCount())
return True
def _initialize(self):
if platform.system() == 'Linux':
if os.geteuid() != 0:
show_error_dialog(
parent=self,
msg=
"You must run with root privileges in order to save any configuration"
)
self.ui.chkAutoRun.setEnabled(False)
self.ui.timeAutoRun.setEnabled(False)
cron_val = get_cron_setting()
if cron_val:
self.ui.timeAutoRun.setTime(
QTime(cron_val.hour, cron_val.minute))
for p in self.parsers:
self.ui.comboParser.addItem(p.get_parser_name())
# Populate UI with YAML data
if os.path.isfile(gui_settings.CONFIG_FILE):
with open(gui_settings.CONFIG_FILE, 'r') as stream:
config_data = yaml.load(stream)
try:
self.ui.txtCompanyID.setText(config_data['company_id'])
self.ui.txtAPIKey.setText(config_data['api_key'])
self.ui.txtHotlistLocation.setText(config_data['hotlist_path'])
self.ui.txtWebServer.setText(config_data['server_base_url'])
parser_idx = [
i for i, p in enumerate(self.parsers)
if p.__class__.__module__.split('.')[-1] ==
config_data['hotlist_parser']
][0]
self.ui.comboParser.setCurrentIndex(parser_idx)
if platform.system() == 'Windows':
tasks = os.popen("schtasks.exe").read()
if gui_settings.TASK_NAME in tasks:
openalpr_task = [
t for t in tasks.splitlines()
if gui_settings.TASK_NAME in t
]
if len(openalpr_task) == 0:
raise RuntimeError(
f'Could not locate {gui_settings.TASK_NAME} in scheduled tasks'
)
time_str = ''.join(openalpr_task[0].split()[2:4])
scheduled_time = datetime.strptime(
time_str, '%I:%M:%S%p')
self.ui.chkAutoRun.setChecked(True)
self.ui.timeAutoRun.setTime(
QTime(scheduled_time.hour, scheduled_time.minute))
if 'state_import' in config_data:
self.ui.txtStateImport.setText(','.join(
[s for s in config_data['state_import']]))
if 'skip_list' in config_data:
self.ui.txtSkipPlates.setText(','.join(
[p for p in config_data['skip_list']]))
except KeyError as exc:
raise RuntimeError(f'Malformed YAML missing {exc} key')
class InUse(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = UiInUse()
self.ui.setupUi(self)
self.db = DataBase()
self.time = QTime(0, 0)
self.elapsed_timer = QElapsedTimer()
self.timer = QTimer(self)
self.info = {}
def update_time(self):
# TODO: Is there more clean way to show timer...?
self.ui.label_time.setText(
(self.time.addMSecs(self.elapsed_timer.elapsed())).toString("hh:mm:ss")
)
def set_page(self, contact):
self.info = self.db.get_info(contact)
self.elapsed_timer.start()
self.timer.timeout.connect(self.update_time)
self.timer.start(500)
self.ui.label_time.setText(self.time.toString("hh:mm:ss"))
self.ui.label_name.setText(self.info["name"] + " 님")
def clear_page(self):
self.timer.stop()
self.ui.label_time.setText("00:00:00")
self.ui.label_name.setText("???")
class CustomTimer(QLCDNumber):
def __init__(self, interval: int, parent=None):
super(CustomTimer, self).__init__(parent)
self.time = QTime()
self.interval = interval
p = self.palette()
p.setColor(QPalette.Background, Qt.black)
p.setColor(p.Light, Qt.darkRed)
self.setPalette(p)
self.timer = None
def timerEvent(self, event: QTimerEvent):
self.display(int(self.time.elapsed() / self.interval))
def start(self):
self.timer = self.startTimer(int(self.interval / 2))
self.time.start()
def stop(self):
if self.timer is not None:
self.killTimer(self.timer)
def reset(self):
self.display(0)
def update(self, next_image: str, value: int, time_left: QTime):
self._progress_bar_animation.stop()
start_value = self._progress_bar.value()
if self._progress_bar_animation.currentValue():
if self._progress_bar_animation.currentValue(
) < self._progress_bar.value():
start_value = self._progress_bar_animation.currentValue()
self._progress_bar_animation.setStartValue(start_value)
self._progress_bar_animation.setEndValue(value * 10)
self._progress_bar_animation.start()
self._current_image_label.setText("Image : " + str(value) + "/" +
str(self._max_value))
time_left_str = ""
if time_left is None:
time_left_str = "Estimation..."
else:
time_left_str = "%dh %dm %ds" % (
time_left.hour(), time_left.minute(), time_left.second())
self._time_label.setText("Temps restant : " + time_left_str)
self._next_image_label.setText("Prochaine image : " + next_image)
if self._taskbar_button is not None:
self._taskbar_button.progress().setValue(value)
def on_update_progress(self, read, total):
"""This methods is called by self.reply.downloadProgress signal
Args:
read (int): Number of bytes readed
total (int): Total bytes to download
"""
if read <= 0:
return
if self.reply.error() != QNetworkReply.NoError:
return
self._file.write(self.reply.readAll())
# compute speed
duration = self.time.secsTo(QTime.currentTime()) + 1
speed = read / duration
remaining = (total - read) / speed
h_remaining = QTime(0, 0, 0, 0).addSecs(remaining).toString()
h_total = self.human_readable_bytes(total)
h_read = self.human_readable_bytes(read)
h_speed = self.human_readable_bytes(speed) + "/sec"
self.info_label.setText(
f"Time remaining {h_remaining} - {h_read} of {h_total} ({h_speed})"
)
# Set progression
self.progress.setRange(0, total)
self.progress.setValue(read)
def itemClicked(self, index):
task: Task = self.model.itemFromIndex(index).data()
self.selected_task = task
checked = self.model.itemFromIndex(index).checkState()
if not checked:
self.dialog = dialog.Display_dialog()
self.dialog.setupUi(self.dialog, task.topic)
self.dialog.show()
self.start_date = QDate.fromString(
task.start_at.strftime("%d/%m/%Y"), 'dd/MM/yyyy')
self.end_date = QDate.fromString(task.end_at.strftime("%d/%m/%Y"),
'dd/MM/yyyy')
self.start_time = QTime.fromString(
task.start_at.strftime("%H:%M:%S"), 'hh:mm:ss')
self.end_time = QTime.fromString(task.end_at.strftime("%H:%M:%S"),
'hh:mm:ss')
self.topic = task.topic
self.location = task.location
self.desc = task.description
self.dialog.title.setText(self.topic)
self.dialog.location.setText(self.location)
self.dialog.from_dateEdit.setDate(self.start_date)
self.dialog.to_dateEdit.setDate(self.end_date)
self.dialog.textEdit_desc.setText(self.desc)
self.dialog.timeEdit.setTime(self.start_time)
self.dialog.to_timeEdit.setTime(self.end_time)
self.dialog.edit_btn.clicked.connect(self.edit_dialog)
else:
details = task.get_detail()
details['status'] = True
self.system.update_task(task.id, details)
def createMailModel(parent):
model = QStandardItemModel(0, 3, parent)
model.setHeaderData(SUBJECT, Qt.Horizontal, "Subject")
model.setHeaderData(SENDER, Qt.Horizontal, "Sender")
model.setHeaderData(DATE, Qt.Horizontal, "Date")
addMail(model, "Happy New Year!", "Grace K. <*****@*****.**>",
QDateTime(QDate(2006, 12, 31), QTime(17, 3)))
addMail(model, "Radically new concept",
"Grace K. <*****@*****.**>",
QDateTime(QDate(2006, 12, 22), QTime(9, 44)))
addMail(model, "Accounts", "*****@*****.**",
QDateTime(QDate(2006, 12, 31), QTime(12, 50)))
addMail(model, "Expenses", "Joe Bloggs <*****@*****.**>",
QDateTime(QDate(2006, 12, 25), QTime(11, 39)))
addMail(model, "Re: Expenses", "Andy <*****@*****.**>",
QDateTime(QDate(2007, 1, 2), QTime(16, 5)))
addMail(model, "Re: Accounts", "Joe Bloggs <*****@*****.**>",
QDateTime(QDate(2007, 1, 3), QTime(14, 18)))
addMail(model, "Re: Accounts", "Andy <*****@*****.**>",
QDateTime(QDate(2007, 1, 3), QTime(14, 26)))
addMail(model, "Sports", "Linda Smith <*****@*****.**>",
QDateTime(QDate(2007, 1, 5), QTime(11, 33)))
addMail(model, "AW: Sports", "Rolf Newschweinstein <*****@*****.**>",
QDateTime(QDate(2007, 1, 5), QTime(12, 0)))
addMail(model, "RE: Sports", "Petra Schmidt <*****@*****.**>",
QDateTime(QDate(2007, 1, 5), QTime(12, 1)))
return model
def mediapositionChange(self):
mediaPosition = self.mediaPlayer.position()
currentTimeMedia = QTime(0, 0, 0)
currentTimeMedia = currentTimeMedia.addMSecs(mediaPosition)
self.ui.onceU.setText(currentTimeMedia.toString("HH:mm:ss"))
self.ui.slider.setRange(0, self.mediaPlayer.duration())
self.ui.slider.setValue(self.mediaPlayer.position())
def mediaPositionChanged(self):
self.ui.slTimeBarre.valueChanged.disconnect(self.timeBarreChanged)
mediaPosition = self.mediaPlayer.position()
self.ui.slTimeBarre.setValue(mediaPosition)
currentTime = QTime(0, 0, 0)
currentTime = currentTime.addMSecs(mediaPosition)
self.ui.lbTimeReal.setText(currentTime.toString("HH:mm:ss"))
self.ui.slTimeBarre.valueChanged.connect(self.timeBarreChanged)
def changeTime(self):
self.mediaPlayer.positionChanged.disconnect(self.updateTime)
print('Time CHANGED')
self.mediaPlayer.setPosition(self.ui.sliderTime.value())
localTime = QTime(0, 0, 0)
currentTime = localTime.addMSecs(self.mediaPlayer.position())
self.ui.timePlayed.setText(currentTime.toString("HH:mm:ss"))
self.mediaPlayer.positionChanged.connect(self.updateTime)
def mediaPositionChanged(self):
self.ui.sTpsCourant.valueChanged.disconnect(self.sliderPositionChanged)
mediaPosition = self.mediaPlayer.position()
self.ui.sTpsCourant.setValue(mediaPosition) ##############
currentTimeMedia = QTime(0, 0, 0)
currentTimeMedia = currentTimeMedia.addMSecs(mediaPosition)
self.ui.lTpsCourant.setText(currentTimeMedia.toString("HH:mm:ss"))
self.ui.sTpsCourant.valueChanged.connect(self.sliderPositionChanged)
def avancee(self):
self.ui.sTpsCourant.valueChanged.disconnect(self.avanceSlider)
mediaPosition = self.mediaPlayer.position()
currentTimeMedia = QTime(0, 0, 0)
currentTimeMedia = currentTimeMedia.addMSecs(mediaPosition)
self.ui.lAvanceeTps.setText(currentTimeMedia.toString("HH:mm:ss"))
self.ui.sTpsCourant.setValue(mediaPosition)
self.ui.sTpsCourant.valueChanged.connect(self.avanceSlider)
def mediaDurationChanged(self):
print("mediaLoaded")
self.ui.lTempsCourant.setText("00:00:00")
mediaDuration = self.mediaPlayer.duration()
self.ui.sTempsCourant.setRange(0, mediaDuration) ##########
totalTimeMedia = QTime(0, 0, 0)
totalTimeMedia = totalTimeMedia.addMSecs(mediaDuration)
self.ui.lTempsTotal.setText(totalTimeMedia.toString("HH:mm:ss"))
def PLAY(self):
print('PLAY PRESSED')
self.mediaPlayer.setVolume(self.ui.dial_volumen.value())
self.mediaPlayer.play()
localTime = QTime(0, 0, 0)
totalTime = localTime.addMSecs(self.mediaPlayer.duration())
self.ui.sliderTime.setMaximum(self.mediaPlayer.duration())
self.ui.timeTotal.setText(totalTime.toString("HH:mm:ss"))
def qtime_to_ms(qtime: QTime) -> int:
"""
exchange milliseconds from QTime type.
"""
ms = (qtime.hour() * 3600) + (qtime.minute() * 60) + qtime.second()
ms *= 1000 # msec 用に1000倍する
ms += qtime.msec()
return ms
def _inputCheck(self, value):
"""Checks if given time is proper type"""
if isinstance(value, datetime.time):
self._current_value = QTime(value)
elif isinstance(value, QTime):
self._current_value = value
elif value is False:
self._current_value = QTime(0, 0, 0, 0)
else:
raise TypeError("current_time must be datetime.time or QTime object, or set to False")
def testQTimeValid(self):
'''QDataStream <<>> QTime - valid'''
self.stream << QTime(12, 12, 21)
res = QTime()
self.read_stream >> res
self.assertEqual(res, QTime(12, 12, 21))
self.assertTrue(res.isValid())
self.assertFalse(res.isNull())
def mediaPositionChanged(self):
mediaPosition = self.mediaPlayer.position()
self.ui.timeline.setValue(mediaPosition)
currentTimeMedia = QTime(
0,
0,
0,
)
currentTimeMedia = currentTimeMedia.addMSecs(mediaPosition)
self.ui.debut.setText(currentTimeMedia.toString("HH:mm:ss"))
def mediaDurationCnahged(self):
print("mediaLoaded")
self.ui.lTemps.setText("00:00:00") #12
mediaDuration = self.mediaPlayer.duration(
) #donne le temps en milisecondes
self.ui.sTimeLine.setRange(0, mediaDuration) #12
totalTimeMedia = QTime(0, 0, 0)
totalTimeMedia = totalTimeMedia.addMSecs(
mediaDuration) #convertir de milisecondes en H:m:s
self.ui.lTempsTotal.setText(totalTimeMedia.toString("HH:mm:ss"))
def QTime2ms(QTime):
'''
arg QTime
return int
'''
h = QTime.hour()
m = QTime.minute()
s = QTime.second()
ms = QTime.msec()
return h * 3600000 + m * 60000 + s * 1000 + ms
def mediaDurationChanged(self):
self.ui.debut.setText("00:00:00")
mediaDuration = self.mediaPlayer.duration(
) #recoit le temps total en Millisec
self.ui.timeline.setRange(
0, mediaDuration
) #découpe le timeline proportionnelement au temps en millisec
totalTimeMedia = QTime(0, 0, 0)
totalTimeMedia = totalTimeMedia.addMSecs(
mediaDuration) #convertit le temps total en h:m:s
self.ui.fin.setText(totalTimeMedia.toString("HH:mm:ss"))
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = UiInUse()
self.ui.setupUi(self)
self.db = DataBase()
self.time = QTime(0, 0)
self.elapsed_timer = QElapsedTimer()
self.timer = QTimer(self)
self.info = {}
def empty(self):
self.ui.callsign.setText('')
self.ui.departure.setText('')
self.ui.destination.setText('')
self.ui.alternate.setText('')
now = datetime.utcnow()
slight_future = now + timedelta(minutes=20)
self.ui.departure_time.setTime(QTime(slight_future.hour, slight_future.minute))
self.ui.departure_date.setDate(QDate(slight_future.year, slight_future.month, slight_future.day))
self.ui.route.setPlainText('')
self.ui.departure_runway.setText('')
self.ui.sid.setText('')
self.ui.cruise_altitude.setText('')
self.ui.cruise_speed.setText('')
self.ui.star.setText('')
self.ui.destination_runway.setText('')
self.ui.aircraft.setText('')
self.ui.airline.setText('')
self.ui.flight_code.setText('')
self.ui.distance.setText('')
self.ui.block_time.setTime(QTime(0, 0))
self.ui.equipment.setText('')
self.ui.equipment_suffix.setText('')
self.ui.pax.setText('')
self.ui.cargo.setText('')
self.ui.zfw.setText('')
self.ui.remarks.setPlainText('')
self.ui.fuel_endurance.setTime(QTime(0, 0))
self.ui.block_fuel.setText('')
self.ui.tow.setText('')
pilot_name = self.gui_root.fslapp.settings.get('pilot', 'name')
pilot_base = self.gui_root.fslapp.settings.get('pilot', 'base')
if pilot_name:
self.ui.pilot_name.setText(pilot_name)
else:
self.ui.pilot_name.setText('')
if pilot_base:
self.ui.pilot_base.setText(pilot_base)
else:
self.ui.pilot_base.setText('')
self.set_populated_plan(None)
def __init__(self, parent: QWidget, window: MainWindow):
super().__init__(parent)
self.pWindow = window
self.strokeX = []
self.strokeY = []
self.strokeT = []
self.timing = QTime()
self.timing.start()
self.paused = 0
self.painter = QPainter()
self.setStyleSheet("background-color: white;")
def __init__(self, interval: int, parent=None):
super(CustomTimer, self).__init__(parent)
self.time = QTime()
self.interval = interval
p = self.palette()
p.setColor(QPalette.Background, Qt.black)
p.setColor(p.Light, Qt.darkRed)
self.setPalette(p)
self.timer = None
def updateCurrentTime(self, currentInfo):
if currentInfo:
currentTime = QTime((currentInfo / 3600) % 60,
(currentInfo / 60) % 60, currentInfo % 60,
(currentInfo * 1000) % 1000)
format = 'hh:mm:ss' if self.duration > 3600 else 'mm:ss'
currentTimeStr = currentTime.toString(format)
else:
currentTimeStr = '00:00'
self.labelCurrentTime.setText(currentTimeStr)
def updateTime(self):
self.ui.sliderTime.valueChanged.disconnect(self.changeTime)
localTime = QTime(0, 0, 0)
currentTime = localTime.addMSecs(self.mediaPlayer.position())
#print(self.mediaPlayer.position()-self.mediaPlayer.duration())
timeLeft = localTime.addMSecs(self.mediaPlayer.duration() -
self.mediaPlayer.position())
#h, res = divmod(t, 3600)
#m, s = divmod(res, 60)
#time_str = f'{int(h):02}:{int(m):02}:{int(s):02}'
self.ui.timePlayed.setText(currentTime.toString("HH:mm:ss"))
self.ui.timeTotal.setText('-' + timeLeft.toString("HH:mm:ss"))
self.ui.sliderTime.setValue(self.mediaPlayer.position())
self.ui.sliderTime.valueChanged.connect(self.changeTime)
def run_worker(self):
"""
Executed the Worker in separate thread
"""
# exec(open('restarter.py').read())
# sys.exit()
self.update_session_state()
currentTime = QTime().currentTime()
fromTime = QTime(int(self.settings.TECHFROMHOUR),
int(self.settings.TECHFROMMIN))
toTime = QTime(int(self.settings.TECHTOHOUR),
int(self.settings.TECHTOMIN))
sessionState = self.lblMarket.text()
if fromTime < currentTime < toTime:
print("Worker skept-Technical break : ",
fromTime.toString("hh:mm"), " to ", toTime.toString("hh:mm"))
self.update_console("Technical break untill " +
toTime.toString("hh:mm"))
else:
self.update_console("Starting Worker- UI Paused")
self.uiTimer.stop(
) # to not cause an errors when lists will be resetted
worker = Worker(
self.ibkrworker.process_positions_candidates
) # Any other args, kwargs are passed to the run function
worker.signals.result.connect(self.update_ui)
worker.signals.status.connect(self.update_status)
worker.signals.notification.connect(self.update_console)
# Execute
self.threadpool.start(worker)
def durationChanged(self, duration):
self.repeat_control.set_duration(duration)
duration /= 1000
self.duration = duration
totalTime = QTime((duration / 3600) % 60, (duration / 60) % 60,
(duration % 60), (duration * 1000) % 1000)
format = 'hh:mm:ss' if duration > 3600 else 'mm:ss'
totalTimeStr = totalTime.toString(format)
self.labelTotalTime.setText(totalTimeStr)
self.seekBar.setMaximum(duration)
def timeWorker(self):
"""
Updateting elapsed time.
"""
timer = QTime()
timer.start()
self.breaker = 0
while self.breaker != 1:
time.sleep(1)
m, s = divmod(timer.elapsed() // 1000, 60)
h, m = divmod(m, 60)
self.lblTime.setText("%d:%02d:%02d" % (h, m, s))
def testQTime(self):
time = datetime.time(11, 14, 0, 1000)
other = QTime(time)
self.assertEqual(time.hour, other.hour())
self.assertEqual(time.minute, other.minute())
self.assertEqual(time.second, other.second())
self.assertEqual(time.microsecond/1000, other.msec())
self.assertEqual(time, other.toPython())
def testInsert(self):
myHash = {}
qdate = QDate.currentDate()
qdatetime = QDateTime.currentDateTime()
qtime = QTime.currentTime()
qurl = QUrl("http://www.pyside.org")
qpoint = QPoint(12, 42)
myHash[qdate] = "QDate"
myHash[qdatetime] = "QDateTime"
myHash[qtime] = "QTime"
myHash[qurl] = "QUrl"
myHash[qpoint] = "QPoint"
self.assertEqual(myHash[qdate], "QDate")
self.assertEqual(myHash[qdatetime], "QDateTime")
self.assertEqual(myHash[qtime], "QTime")
self.assertEqual(myHash[qurl], "QUrl")
self.assertEqual(myHash[qpoint], "QPoint")
def run(self):
t = QTime()
t.start()
time.sleep(2) # Sleep 2 seconds
