def __init__(self):
super().__init__()
# Título da janela.
self.setWindowTitle('PySide2 QProgressDialog().')
# Ícone da janela principal
icon = QIcon()
icon.addPixmap(QPixmap('../../../images/icons/icon.png'))
self.setWindowIcon(icon)
# Tamanho inicial da janela.
screen_size = app.desktop().geometry()
# screen_size = app.primaryScreen().geometry()
width = screen_size.width()
height = screen_size.height()
self.resize(width / 2, height / 2)
# Tamanho mínimo da janela.
self.setMinimumSize(width / 2, height / 2)
# Tamanho maximo da janela.
self.setMaximumSize(width - 200, height - 200)
# Widget central.
widget = QWidget()
self.setCentralWidget(widget)
# Widgets.
vbox = QVBoxLayout()
widget.setLayout(vbox)
self.label = QLabel(
'A janela de processo irá abrir sozinha quando o evento do'
'timer (QTimer) for iniciado.\n'
'Ao clicar no botão cancelar o evento é interrompido.\n'
'Quando o diálogo de progresso atinge o maximo o envento é '
'interrompido.', )
self.label.setAlignment(Qt.AlignCenter)
vbox.addWidget(self.label)
button = QPushButton('Abrir diálogo novamente')
button.clicked.connect(self.start_progress_again)
vbox.addWidget(button)
self.progress_dialog = QProgressDialog(
parent=self,
labelText=(
'Ao clicar em cancelar o timer (QTimer) será parado e a barra '
'de progresso é reiniciada.'),
cancelButtonText='Cancelar',
minimum=0,
maximum=100,
)
self.progress_dialog.setWindowTitle('Titulo da janela de diálogo')
self.progress_dialog.setModal(True)
self.progress_dialog.canceled.connect(self.stop_progress)
self.timer = QTimer()
self.timer.timeout.connect(self.start_progress)
self.timer.start(1000)
def generatePrediction(self):
self.method_name = self.choose_method.currentText()
self.prediction_length = self.choose_prediction_length.value()
form_treatments = sorted(
[
Treatment(0,
t_date.date().toPython(), 1)
for t_date in self.treatments
],
key=attrgetter("date"),
)
treatments = self.patient.treatments + form_treatments
self.accept()
self.progress_bar = QProgressBar()
self.progress_bar.setRange(0, 0)
self.progress_dialog = QProgressDialog(
f"Generowanie predykcji za pomocą {self.method_name}", None, 0, 1)
self.progress_dialog.setWindowFlags(Qt.Dialog | Qt.FramelessWindowHint)
self.progress_dialog.setWindowModality(Qt.WindowModal)
self.progress_dialog.setBar(self.progress_bar)
prediction_fun = self.name_to_impl[self.method_name]
self.progress_dialog.show()
self.runnable = PredictionRunnable(
prediction_fun,
self.patient.measurements,
self.prediction_length,
treatments,
)
self.runnable.result.connect(self.handlePrediction)
self.runnable.start()
def add_app_ui(self, manifests: List[str]):
def on_progress(value):
if value != self.app_progress.maximum():
return
self.add_app_thread.progress.disconnect(on_progress)
del self.app_progress
del self.add_app_thread
def on_failed(exc_info):
msg = QMessageBox(
QMessageBox.Critical,
"Fail to add application",
f"Failed to add application: \n\n{exc_info[0].__name__}: {exc_info[1]}",
)
msg.setDetailedText("".join(traceback.format_exception(*exc_info)))
msg.exec_()
self.app_progress = QProgressDialog("Installing app", "Cancel", 0, 100)
self.add_app_thread = _FetchRegistryThread(self, apps=manifests)
self.add_app_thread.progress.connect(self.app_progress.setValue)
self.add_app_thread.progress.connect(on_progress)
self.add_app_thread.items.connect(self.app_progress.setMaximum)
self.add_app_thread.label.connect(self.app_progress.setLabelText)
self.add_app_thread.failed.connect(on_failed)
self.app_progress.canceled.connect(self.add_app_thread.cancel)
self.add_app_thread.start()
self.app_progress.exec_()
def openProject(self, filename=None):
if not filename:
(filename, ftype) = QFileDialog.getOpenFileName(
self,
"Choose project file",
dir=self.lastProjectDirectory,
filter="Projects (*.prj)",
options=QFileDialog.DontResolveSymlinks
| QFileDialog.HideNameFilterDetails)
if filename:
self.lastProjectDirectory = str(Path(filename).parent)
self.createProject()
progress = QProgressDialog('', None, 0, 100, self)
try:
self.project.load(filename, progress)
self.lastProjectFile = filename
if filename in self.recentProjectFiles:
self.recentProjectFiles.remove(filename)
self.recentProjectFiles.insert(0, filename)
self.updateRecentMenu()
self.updateShaderMenu()
self.editor.setProject(self.project)
self.saveSettings()
except BaseException as e:
progress.close()
raise e
def _init_statusbar(self):
self._progressbar = QProgressBar()
self._progressbar.setMinimum(0)
self._progressbar.setMaximum(100)
self._progressbar.hide()
self.statusBar().addPermanentWidget(self._progressbar)
self._progress_dialog = QProgressDialog("Waiting...", "Cancel", 0, 100,
self)
self._progress_dialog.setAutoClose(False)
self._progress_dialog.setWindowFlags(
self._progress_dialog.windowFlags()
& ~Qt.WindowContextHelpButtonHint)
self._progress_dialog.setModal(True)
self._progress_dialog.setMinimumDuration(2**31 - 1)
def on_cancel():
if self.workspace is None:
return
for job in self.workspace.instance.jobs:
if job.blocking:
job.keyboard_interrupt()
break
self._progress_dialog.canceled.connect(on_cancel)
self._progress_dialog.close()
def preselect(self):
progress = QProgressDialog('', None, 0, 100, self)
try:
self.project.preselect(progress)
except BaseException as e:
progress.close()
raise e
def load_default_apps(self):
def on_progress(value):
if value != self.default_app_progress.maximum():
return
self.settings.setValue("apps/_meta/isDefaultLoaded", True)
logger.info("Default apps loaded")
self.default_app_thread.progress.disconnect(on_progress)
del self.default_app_progress
del self.default_app_thread
self.default_app_progress = QProgressDialog("Loading default apps",
"Cancel", 0, 100)
self.default_app_thread = _FetchRegistryThread(self)
self.default_app_thread.progress.connect(
self.default_app_progress.setValue)
self.default_app_thread.progress.connect(on_progress)
self.default_app_thread.items.connect(
self.default_app_progress.setMaximum)
self.default_app_thread.label.connect(
self.default_app_progress.setLabelText)
self.default_app_progress.canceled.connect(
self.default_app_thread.cancel)
self.default_app_thread.start()
self.default_app_progress.show()
def __init__(self):
super(MainWindow, self).__init__()
# Caminho até o arquivo de interface.
# path = QDir(__file__).currentPath()
# ui_file = QDir(path).filePath('MainWindow.ui')
ui_file = QDir(QDir(__file__).currentPath()).filePath('MainWindow.ui')
self.ui = QUiLoader().load(ui_file, None)
# Widgets.
self.label = self.ui.findChild(QObject, 'label')
button = self.ui.findChild(QObject, 'button')
button.clicked.connect(self.start_progress_again)
self.progress_dialog = QProgressDialog(
parent=self.ui,
labelText=(
'Ao clicar em cancelar o timer (QTimer) será parado e a barra '
'de progresso é reiniciada.'
),
cancelButtonText='Cancelar',
minimum=0,
maximum=100,
)
self.progress_dialog.setWindowTitle('Titulo da janela de diálogo')
self.progress_dialog.setModal(True)
self.progress_dialog.canceled.connect(self.stop_progress)
self.timer = QTimer()
self.timer.timeout.connect(self.start_progress)
self.timer.start(1000)
self.ui.show()
def send_program(self):
selections = self.ui.programListWidget.selectedItems()
for selection in selections:
filename = selection.text()
filepath = self.dir.path() + '/' + filename
port_chosen = self.ui.serialPortChooser.currentText()
confirm = ConfirmSend(self)
confirm.ui.dialogLabel.setText(f'Send program \'{filename}\'?')
confirm.exec()
if confirm.result() == QDialog.Accepted:
self.send_status = QProgressDialog(self)
self.sender = Sender(
port_chosen, filepath,
globalSettings.value('serialport/baudrate'),
globalSettings.value('serialport/databits'),
globalSettings.value('serialport/parity'),
globalSettings.value('serialport/stopbits'),
globalSettings.value('serialport/flowcontrol'), self)
self.send_status.setMaximum(self.sender.file.size())
self.send_status.canceled.connect(self.sender.cancel)
self.sender.signals.update_status.connect(
self.send_status.setValue)
self.thread_pool.start(self.sender)
self.send_status.exec_()
self.send_status.deleteLater()
def prepare(self):
modelfile = 'models/median_b{}.mdl'.format(self.block)
try:
model = load(modelfile)
except FileNotFoundError:
QMessageBox.critical(
self, self.tr('Error'),
self.tr('Model not found ("{}")!'.format(modelfile)))
return
limit = model.best_ntree_limit if hasattr(model,
'best_ntree_limit') else None
columns = model._features_count
if columns == 8:
levels = 1
windows = 1
elif columns == 24:
levels = 3
windows = 1
elif columns == 96:
levels = 3
windows = 4
elif columns == 128:
levels = 4
windows = 4
else:
QMessageBox.critical(self, self.tr('Error'),
self.tr('Unknown model format!'))
return
padded = pad_image(self.gray, self.block)
rows, cols = padded.shape
self.prob = np.zeros(
((rows // self.block) + 1, (cols // self.block) + 1))
self.var = np.zeros_like(self.prob)
progress = QProgressDialog(self.tr('Detecting median filter...'),
self.tr('Cancel'), 0, self.prob.size, self)
progress.canceled.connect(self.cancel)
progress.setWindowModality(Qt.WindowModal)
k = 0
self.canceled = False
for i in range(0, rows, self.block):
for j in range(0, cols, self.block):
roi = padded[i:i + self.block, j:j + self.block]
x = np.reshape(get_features(roi, levels, windows),
(1, columns))
y = model.predict_proba(x, ntree_limit=limit)[0, 1]
ib = i // self.block
jb = j // self.block
self.var[ib, jb] = np.var(roi)
self.prob[ib, jb] = y
if self.canceled:
self.prob = self.var = None
progress.close()
return
progress.setValue(k)
k += 1
progress.close()
self.process()
def massive_merge(self):
# Comprueba si la carpeta de destino y la carpeta de origen son válidas
# Carga los nombres en partes y los nombres de archivo completos
if path.isdir(self.source_folder.text()) and path.isdir(
self.dest_folder.text()):
splitted_names, pdf_files = self.load_files(
self.source_folder.text())
# Toma el orden de los archivos desde la lista del pdf_order_widget
order_list = [
str(self.pdf_order_widget.item(i).text())
for i in range(self.pdf_order_widget.count())
]
print(f'order list: {order_list}')
if order_list:
# toma la lista con los números de póliza únicamente
polizas = list(set([x[0] for x in splitted_names]))
print(f'polizas : {polizas}')
progress = QProgressDialog("Unificando archivos...", "Abortar",
0, len(polizas), self)
progress.setWindowModality(Qt.WindowModal)
try:
for poliza in polizas:
progress.setValue(polizas.index(poliza))
pdf_merger = PdfWriter()
for part in order_list:
pattern = str(poliza + "[_\s]" + part + ".*")
r = re.compile(pattern)
file_name = list(filter(r.match, pdf_files))
print(f'file_name: {file_name}')
if file_name:
fullfile_name = path.join(
self.source_folder.text(), file_name[0])
pdf_merger.addpages(
PdfReader(fullfile_name).pages)
file_dest = path.join(self.dest_folder.text(),
'.'.join([poliza, 'pdf']))
print(f'file dest: {file_dest}')
pdf_merger.write(file_dest)
# pdf_merger.close()
if progress.wasCanceled():
break
progress.setValue(len(polizas))
self.dialog_message(
'La Unificación masiva ha concluído con éxito!',
QMessageBox.Information)
except Exception as e:
self.dialog_message(str(e), QMessageBox.Warning)
else:
self.dialog_message(
'La lista con el orden de las partes está vacía, por favor cargue los archivos!',
QMessageBox.Warning)
else:
self.dialog_message(
'La carpeta de origen o destino es inválida, '
'Por favor ingrese carpetas válidas!', QMessageBox.Warning)
def _download_progress_callback(self, total, so_far):
if not self._download_progress_dialog:
self._download_progress_dialog = QProgressDialog(
_("Downloading the selected database."), None, 0, 100, self)
self._download_progress_dialog.setWindowTitle(
_("Download in progress"))
percentage = int((so_far / total) * 100)
self._download_progress_dialog.setLabelText(
_("Downloading the selected database. Downloaded {so_far} of {total}."
).format(so_far=format_size(so_far), total=format_size(total)))
self._download_progress_dialog.setValue(percentage)
def __init__(self, title, description, max_value):
QProgressDialog.__init__(self)
self.setWindowTitle(title)
self.setLabelText(description)
self.setMaximum(max_value)
self.setWindowModality(Qt.ApplicationModal)
self.setWindowFlags(Qt.CustomizeWindowHint | Qt.WindowTitleHint)
self.setFixedSize(self.size())
self.setAutoReset(False)
self.setCancelButton(None)
self.show()
def exportViews(self):
filename, ok = QInputDialog.getText(self, "View Image Filename",
"Png filename")
if ok and len(filename) > 0:
progress = QProgressDialog('', None, 0, 100, self)
try:
self.project.exportviews(self.view.context(), filename,
progress)
except BaseException as e:
progress.close()
raise e
def __init_progress(self, steps: int):
"""__init_progress will init the progress bar
Arguments:
steps {int} -- Number of step of the progress bar
"""
self.progress = QProgressDialog('Operation in progress.', 'Stop', 0,
steps)
self.progress_start = 0
self.progress.setMinimumWidth(400)
self.progress.setMinimumHeight(100)
self.progress.show()
def load_dataList(self, nameList, showThumbnail=True, progressBar=True):
self.dataList.clear()
if progressBar:
progress = QProgressDialog("Loading data...", "Abort", \
0, len(nameList), self.window)
progress.setWindowModality(Qt.WindowModal)
for i, dataName in enumerate(nameList):
newItem = QtWidgets.QListWidgetItem(dataName)
# Mark finished data
if self.in_task and (dataName in self.current_task.finished_data):
newItem.setBackground(QBrush(QColor("#b3b3b3")))
if showThumbnail:
# boring img down sizing and img format converting
img = Image.open(self.current_data_dir + IMG_FOLDER \
+ '/' + dataName + '.' + IMG_EXT)
w, h = img.size
img = img.resize((128, int(128 * h / w)))
img = img.convert("RGBA")
qimg = QImage(img.tobytes('raw', 'RGBA'), img.size[0], \
img.size[1], QImage.Format_RGBA8888)
thumbnail = QIcon()
thumbnail.addPixmap(QtGui.QPixmap.fromImage(qimg))
newItem.setIcon(thumbnail)
# pre load all the labels
label_dir = self.current_data_dir + LEBEL_FOLDER \
+ '/' + dataName + '.txt'
if os.path.exists(label_dir):
with open(label_dir, 'r') as label_file:
bboxs = []
for line in label_file:
bbox_l = line.split()
class_num = int(bbox_l[0])
centerX = int(float(bbox_l[1]) * w)
centerY = int(float(bbox_l[2]) * h)
width = int(float(bbox_l[3]) * w)
height = int(float(bbox_l[4]) * h)
new_bbox = BBox([centerX, centerY, width, height],\
[w, h], class_num)
bboxs.append(new_bbox)
label_table[dataName] = bboxs
else:
# self.error_msg("Cannot find label: " + \
# label_dir)
# if the label do not exist, create an empty bbox list
bboxs = []
label_table[dataName] = bboxs
self.dataList.addItem(newItem)
if progressBar:
progress.setValue(i)
if progress.wasCanceled():
break
if progressBar:
progress.setValue(len(nameList))
def save_animation(self):
if self.last_result is not None:
filename, format_str = self.file_dialog.getSaveFileName(self, self.tr("Save the animation of this SSU result"), None, self.tr("MPEG-4 Video File (*.mp4);;Graphics Interchange Format (*.gif)"))
if filename is None or filename == "":
return
progress = QProgressDialog(self)
progress.setRange(0, 100)
progress.setLabelText(self.tr("Saving Animation [{0} Frames]").format(self.last_result.n_iterations))
canceled = False
def save_callback(i, n):
if progress.wasCanceled():
nonlocal canceled
canceled = True
raise StopIteration()
progress.setValue((i+1)/n*100)
QCoreApplication.processEvents()
self.show_result(self.last_result)
# plt.rcParams["savefig.dpi"] = 120.0
if "*.gif" in format_str:
if not ImageMagickWriter.isAvailable():
self.normal_msg.setWindowTitle(self.tr("Error"))
self.normal_msg.setText(self.tr("ImageMagick is not installed, please download and install it from its offical website (https://imagemagick.org/index.php)."))
self.normal_msg.exec_()
else:
self.animation.save(filename, writer="imagemagick", fps=30, progress_callback=save_callback)
elif "*.mp4" in format_str:
if not FFMpegWriter.isAvailable():
self.normal_msg.setWindowTitle(self.tr("Error"))
self.normal_msg.setText(self.tr("FFMpeg is not installed, please download and install it from its offical website (https://ffmpeg.org/)."))
self.normal_msg.exec_()
else:
self.animation.save(filename, writer="ffmpeg", fps=30, progress_callback=save_callback)
# plt.rcParams["savefig.dpi"] = 300.0
if not canceled:
progress.setValue(100)
def run(self):
steps = len(self.recipe.get('actions', [])) * 2
print("{} steps in recipe".format(steps))
executor = FuturaRecipeExecutor(self)
def run_thread():
QApplication.processEvents()
for i in executor.recipe_generator():
print (i['message'])
yield i
signals.update_recipe.emit()
signals.show_recipe_actions.emit()
signals.reset_status_message.emit()
self.thread = GeneratorThread(run_thread, steps)
print('starting thread')
signals.change_status_message.emit('Loading Recipe Data...')
progress = QProgressDialog('Loading Recipe Data...', None, 0, steps, findMainWindow().centralWidget())
progress.setWindowModality(Qt.WindowModal)
progress.setWindowTitle('Loading...')
progress.show()
signals.thread_progress.connect(progress.setValue)
signals.thread_progress.emit(1)
self.thread.start()
print('thread started...')
def act(self):
if not self.project:
logging.fatal("Entered loading without locating a project.")
sys.exit(1)
logging.info("Entered Loading state.")
self.progress_dialog = QProgressDialog("Loading modules...", "Quit", 0, 0)
self.progress_dialog.setWindowTitle("Paragon - Loading")
self.progress_dialog.setWindowIcon(QIcon("paragon.ico"))
self.progress_dialog.setAutoClose(False)
self.progress_dialog.hide()
self.progress_dialog.show()
self.loading_thread = LoadingWorker(self.project)
self.loading_thread.over.connect(self._on_loading_success)
self.loading_thread.failed.connect(self._on_loading_failure)
self.loading_thread.start()
def convert_files(self):
self.centroids = None # IF user quits conversion before any waveforms are generated
self.settings = self.view.get_settings()
if self.settings == None: # IF filedialog is cancelled then stop!
return
self.model = Model(**self.settings, parent=self)
self.model.finished.connect(self.update_settings)
self.model.start()
self.progress = QProgressDialog("Creating files", "Cancel", 0, 100,
self.view, Qt.WindowStaysOnTopHint)
self.progress.canceled.connect(self.canceled)
self.progress.setFixedWidth(
self.progress.width() +
20) #Margin and fixed to avoid annoying jumping
self.progress.show()
def exportSelection(self):
(filename, ftype) = QFileDialog.getSaveFileName(
self,
"Choose ply file",
dir=self.lastProjectDirectory,
filter="Meshes (*.ply)",
options=QFileDialog.DontResolveSymlinks
| QFileDialog.HideNameFilterDetails)
if filename:
if not filename.endswith('.ply'):
filename += '.ply'
progress = QProgressDialog('', None, 0, 100, self)
try:
self.project.exportply(filename, progress)
except BaseException as e:
progress.close()
raise e
def download(self):
'''
Download the youtube URL to the output directory.
'''
if (self.check_url_is_valid(self.url) == False
or self.check_url_is_valid(self.output) == False):
self.show_error_dialog('Invalid input')
return
try:
self.yt = StreamLoader(self.url)
except:
self.show_error_dialog('Invalid URL')
return
download_list = self.yt.yt.streams.filter(resolution=self.resolution,
only_audio=self.audio_only)
if (len(download_list) == 0):
self.show_error_dialog('There is not any valid file with the '
'selected filter. Please updated it!')
return
download_dialog = DownloadList(download_list)
download_dialog.exec_()
item_for_download = download_dialog.currentItem
if (download_dialog.download_pressed == False):
return
self.yt.set_resolution(self.resolution)
self.yt.set_audio_only(self.audio_only)
self.yt.set_output(self.output)
self.yt.set_item_for_download(item_for_download)
self.download_thread = QThread()
self.progress_dialog = QProgressDialog()
self.progress_dialog.setWindowTitle('Downloading')
self.progress_dialog.setCancelButton(None)
self.yt.moveToThread(self.download_thread)
self.download_thread.started.connect(self.yt.start_thread)
self.yt.finished.connect(self.download_thread.quit)
self.yt.yt.register_on_progress_callback(self.yt.show_progress_bar)
self.yt.total_bytes.connect(self.progress_dialog.setMaximum)
self.yt.bytes_remaining.connect(self.progress_dialog.setValue)
self.progress_dialog.show()
self.download_thread.start()
def downloadChapters(self, chapters):
chp = self.info['chapters']
# Get indexes from Info dictionary
idx = [
i for i in range(len(chp)) for volume, name in chapters
if name == chp[i]['name'] and volume == chp[i]['volume']
]
# Create Progress Dialog
progress = QProgressDialog('Downloading Chapters', 'Cancel', 0,
len(idx))
# Show Dialog
progress.show()
self.app.processEvents()
# Dump chapters
for i in range(len(idx)):
if progress.wasCanceled():
return False
Utils.dumpChapterText(self.info, idx[i], self.settings)
progress.setValue(i)
self.app.processEvents()
# Return status
return True
def importMVEScene(self):
(filename, ftype) = QFileDialog.getOpenFileName(
self,
"Choose MVE scene",
dir=self.lastImportDirectory,
filter="MVE Scene (synth_0.out)",
options=QFileDialog.DontResolveSymlinks)
if filename:
directory = str(Path(filename).parent)
self.lastImportDirectory = directory
progress = QProgressDialog('', None, 0, 100, self)
try:
self.project.importmve(directory, progress)
self.view.update()
self.saveSettings()
except BaseException as e:
progress.close()
raise e
def __init__(self, parent, title, **kwargs):
super().__init__(total=0, desc=title, **kwargs, gui=True)
self.sp = None
self.dialog = QProgressDialog(parent)
self.dialog.setModal(True)
self.dialog.setMinimumDuration(500)
self.dialog.setWindowTitle(self.desc)
self.dialog.setAutoClose(False)
self.dialog.setWindowModality(Qt.WindowModal)
self.dialog.setWindowFlag(Qt.WindowCloseButtonHint, False)
self.dialog.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
label = QLabel()
label.setTextFormat(Qt.PlainText)
label.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.dialog.setLabel(label)
self._cancel_event = Event()
self._internal_cancel_event = Event()
self.dialog.canceled.connect(self.user_cancel)
def uploadToHyperthought(self):
auth_control = htauthcontroller.HTAuthorizationController(
self.accessKey)
metadataJson = ht_utilities.dict_to_ht_metadata(
self.usefilterModel.displayed)
progress = QProgressDialog("Uploading files...", "Abort Upload", 0,
len(self.uselistmodel.metadataList), self)
progress.setWindowFlags(Qt.Window | Qt.CustomizeWindowHint
| Qt.WindowTitleHint)
progress.setAttribute(Qt.WA_DeleteOnClose)
self.createUpload.emit(self.uselistmodel.metadataList, auth_control,
self.folderuuid, metadataJson)
self.uploader.currentUploadDone.connect(progress.setValue)
self.uploader.currentlyUploading.connect(progress.setLabelText)
self.uploader.allUploadsDone.connect(progress.accept)
progress.canceled.connect(lambda: self.uploader.interruptUpload())
progress.setFixedSize(500, 100)
progress.exec()
def _update_database(self, area):
if area > FROZEN_AREA_OSM_ID_OFFSET or not has_api_connectivity():
self._on_map_ready()
return
try:
retriever = SemanticChangeRetriever()
self._pending_count = retriever.new_change_count_in(area)
except ConnectionError:
QMessageBox.warning(
self, _("Warning"),
_("Could not retrieve changes in the selected area, using the potentially stale local copy."
))
self._on_map_ready()
return
except UnknownQueueError:
QMessageBox.warning(
self, _("Warning"),
_("The changes queue for the selected database no longer exists on the server, downloading it as if it was a new area."
))
self._download_database(area)
return
if not self._pending_count:
self._on_map_ready()
return
generate_changelog = config().changelogs.enabled
if self._pending_count > 10000 and generate_changelog:
resp = QMessageBox.question(
self, _("Question"),
_("The server reports %s pending changes. Do you really want to generate the changelog from all of them? It might take a while."
) % self._pending_count)
if resp == QMessageBox.StandardButton.Yes:
generate_changelog = False
self._progress = QProgressDialog(
_("Applying changes for the selected database."), None, 0,
self._pending_count, self)
self._progress.setWindowTitle(_("Change application"))
self._applier = ChangesApplier(area, retriever, generate_changelog)
self._applier.will_process_change.connect(self._on_will_process_change)
self._applier.changes_applied.connect(self._on_changes_applied)
self._applier.redownload_requested.connect(
self._on_redownload_requested)
self._applier.start()
def start_collecting_measurements(self, interaction):
if self.sensor_not_responding:
print("DEBUG: warning! Can't start calibration, the sensor is not responding! (in 'RootsApp.start_collecting_measurements()')")
error_msg = QMessageBox()
error_msg.setText("Can't start calibration!")
error_msg.setIcon(QMessageBox.Critical)
error_msg.setInformativeText('The sensor is not responding, make sure it is connected')
error_msg.setWindowTitle("Error")
error_msg.exec_()
else:
print("starting to collect measurements into the database at location ID {0} (in 'RootsApp.start_collecting_measurements()')".format(interaction.ID));
self.is_training_on = True
self.interaction_under_training = interaction
database.delete_measurements_from_location(self.database_connection, interaction.ID) # resets the location measurements
self.progress_dialog = QProgressDialog("Calibrating", "Abort", 0, self.n_measurements_to_collect, self)
self.progress_dialog.setWindowModality(Qt.WindowModal)
self.progress_dialog.setWindowTitle("Calibration")
self.progress_dialog.setFixedSize(400, 200)
self.progress_dialog.setValue(0)
self.progress_dialog.exec_()
def run_testing(self):
if not self.file_names:
self.selected_files.setText(
"No files were selected. Go to menu and "
"select files to test.")
return
# Create new queues every run
self.queues = [
multiprocessing.Queue(maxsize=self.PROCESS_NUMBER),
multiprocessing.Queue(maxsize=self.PROCESS_NUMBER)
]
self.STOP_THREADS = False
progress = QProgressDialog("Starting Docker and VMs", "Abort start", 0,
len(self.file_names) * 2, self)
progress.canceled.connect(self.cancel)
progress.setWindowModality(Qt.WindowModal)
# Create Qthread to show progress
self.thread = QThread()
self.worker = Worker(self, self.file_names, self.queues)
self.worker.moveToThread(self.thread)
# Custom signals connected to own functions for progress dialog
self.show_steps_thread = threading.Thread(target=self.show_steps,
args=(progress, ))
self.show_steps_thread.start()
# Thread start and stop signals connected with slots
self.thread.started.connect(self.worker.run)
self.thread.finished.connect(self.remove_processes)
# Start thread and force to show progress dialog
self.thread.start()
progress.forceShow()
def __init__(self, soundfile, parent):
self.soundfile = soundfile
self.isplaying = False
self.time = 0 # current audio position in frames
self.audio = QMediaPlayer()
self.decoder = QAudioDecoder()
self.is_loaded = False
self.volume = 100
self.isplaying = False
self.decoded_audio = {}
self.only_samples = []
self.decoding_is_finished = False
self.max_bits = 32768
self.signed = False
# File Loading is Asynchronous, so we need to be creative here, doesn't need to be duration but it works
self.audio.durationChanged.connect(self.on_durationChanged)
self.decoder.finished.connect(self.decode_finished_signal)
self.audio.setMedia(QUrl.fromLocalFile(soundfile))
self.decoder.setSourceFilename(
soundfile) # strangely inconsistent file-handling
progress = QProgressDialog("Loading Audio", "Cancel", 0, 0)
progress.setWindowTitle("Progress")
progress.setModal(True)
progress.forceShow()
# It will hang here forever if we don't process the events.
while not self.is_loaded:
QCoreApplication.processEvents()
time.sleep(0.1)
self.decode_audio()
self.np_data = np.array(self.only_samples)
if not self.signed: # don't ask me why this fixes 8 bit samples...
self.np_data = self.np_data - self.max_bits / 2
print(len(self.only_samples))
print(self.max_bits)
progress.close()
self.isvalid = True
