def testTaskFromFunctionWithSubTaskCompletedIsCalledOnce(self): # spellok """ test that when a parent task has subtasks it does emit taskCompleted only once""" self.finished = 0 self.completed = 0 def _on_finished(e): self.finished += 1 def _on_completed(): self.completed += 1 task = QgsTask.fromFunction('test task', run_no_result, on_finished=_on_finished) task.taskCompleted.connect(_on_completed) spy = QSignalSpy(task.taskCompleted) sub_task_1 = QgsTask.fromFunction('test subtask 1', run_no_result, on_finished=_on_finished) sub_task_2 = QgsTask.fromFunction('test subtask 2', run_no_result, on_finished=_on_finished) task.addSubTask(sub_task_1, [], QgsTask.ParentDependsOnSubTask) task.addSubTask(sub_task_2, [], QgsTask.ParentDependsOnSubTask) QgsApplication.taskManager().addTask(task) while task.status() not in [QgsTask.Complete, QgsTask.Terminated]: QCoreApplication.processEvents() while QgsApplication.taskManager().countActiveTasks() > 0: QCoreApplication.processEvents() self.assertEqual(self.completed, 1) self.assertEqual(self.finished, 3) self.assertEqual(len(spy), 1)
def testTaskFromFunctionWithFlags(self): """ test creating task from function with flags""" task = QgsTask.fromFunction('test task', run, 20, flags=QgsTask.Flags()) self.assertFalse(task.canCancel()) task2 = QgsTask.fromFunction('test task', run, 20, flags=QgsTask.CanCancel) self.assertTrue(task2.canCancel())
def __init__(self, settings): QgsTask.__init__(self, 'QConsolidate') self.settings = settings self.project = None self.projectFile = None self.baseDirectory = self.settings['output'] self.dataDirectory = os.path.join(self.baseDirectory, LAYERS_DIRECTORY) self.error = ''
def testTaskFromFunctionWithKwargs(self): """ test creating task from function using kwargs """ task = QgsTask.fromFunction('test task3', run_with_kwargs, result=5, password=1) QgsApplication.taskManager().addTask(task) while task.status() not in [QgsTask.Complete, QgsTask.Terminated]: pass self.assertEqual(task.returned_values, 5) self.assertFalse(task.exception) self.assertEqual(task.status(), QgsTask.Complete)
def testTaskFromFunction(self): """ test creating task from function """ task = QgsTask.fromFunction('test task', run, 20) QgsApplication.taskManager().addTask(task) while task.status() not in [QgsTask.Complete, QgsTask.Terminated]: pass self.assertEqual(task.returned_values, 20) self.assertFalse(task.exception) self.assertEqual(task.status(), QgsTask.Complete) # try a task which cancels itself bad_task = QgsTask.fromFunction('test task2', run, None) QgsApplication.taskManager().addTask(bad_task) while bad_task.status() not in [QgsTask.Complete, QgsTask.Terminated]: pass self.assertFalse(bad_task.returned_values) self.assertTrue(bad_task.exception) self.assertEqual(bad_task.status(), QgsTask.Terminated)
def testTaskFromFunctionFinishedFail(self): """ test that task from function which fails calls finished with exception""" task = QgsTask.fromFunction('test task', run_fail, on_finished=finished_fail) QgsApplication.taskManager().addTask(task) while task.status() not in [QgsTask.Complete, QgsTask.Terminated]: pass while QgsApplication.taskManager().countActiveTasks() > 0: QCoreApplication.processEvents() # check that the finished function was called self.assertTrue(task.exception) self.assertTrue(finished_fail.finished_exception) self.assertEqual(task.exception, finished_fail.finished_exception)
def testTaskFromFunctionFinishedWithVal(self): """ test that task from function can have callback finished function and is passed result values""" task = QgsTask.fromFunction('test task', run_single_val_result, on_finished=finished_single_value_result) QgsApplication.taskManager().addTask(task) while task.status() not in [QgsTask.Complete, QgsTask.Terminated]: pass while QgsApplication.taskManager().countActiveTasks() > 0: QCoreApplication.processEvents() # check that the finished function was called self.assertEqual(task.returned_values, (5)) self.assertFalse(task.exception) self.assertEqual(finished_single_value_result.value, 5)
def testTaskFromFunctionFinished(self): """ test that task from function can have callback finished function""" task = QgsTask.fromFunction('test task', run_no_result, on_finished=finished_no_val) QgsApplication.taskManager().addTask(task) while task.status() not in [QgsTask.Complete, QgsTask.Terminated]: pass while QgsApplication.taskManager().countActiveTasks() > 0: QCoreApplication.processEvents() # check that the finished function was called self.assertFalse(task.returned_values) self.assertFalse(task.exception) self.assertTrue(finished_no_val.called)
def testTaskFromFunctionCanceledWhileQueued(self): """ test that task from finished is called with exception when task is terminated while queued""" task = QgsTask.fromFunction('test task', run_no_result, on_finished=finished_fail) task.hold() QgsApplication.taskManager().addTask(task) task.cancel() while task.status() not in [QgsTask.Complete, QgsTask.Terminated]: pass while QgsApplication.taskManager().countActiveTasks() > 0: QCoreApplication.processEvents() # check that the finished function was called self.assertTrue(task.exception) self.assertTrue(finished_fail.finished_exception) self.assertEqual(task.exception, finished_fail.finished_exception)
def testTaskFromFunctionIsCancellable(self): """ test that task from function can check canceled status """ bad_task = QgsTask.fromFunction('test task4', cancellable) QgsApplication.taskManager().addTask(bad_task) while bad_task.status() != QgsTask.Running: pass bad_task.cancel() while bad_task.status() == QgsTask.Running: pass while QgsApplication.taskManager().countActiveTasks() > 0: QCoreApplication.processEvents() self.assertEqual(bad_task.status(), QgsTask.Terminated) self.assertTrue(bad_task.exception)
def testTaskFromFunctionCanSetProgress(self): """ test that task from function can set progress """ task = QgsTask.fromFunction('test task5', progress_function) QgsApplication.taskManager().addTask(task) while task.status() != QgsTask.Running: pass # wait a fraction so that setProgress gets a chance to be called sleep(0.001) self.assertEqual(task.progress(), 50) self.assertFalse(task.exception) task.cancel() while task.status() == QgsTask.Running: pass while QgsApplication.taskManager().countActiveTasks() > 0: QCoreApplication.processEvents()
def runTask(self, dataRun): def finished(exception, dataResult): def endEditable(): self.layerPolygon.commitChanges() self.layerPolygon.updateExtents() if self.isIniEditable: self.layerPolygon.startEditing() def setRenderLayer(): fileStyle = os.path.join( os.path.dirname( __file__ ), "gimpselectionfeature_with_expression.qml" ) self.layerPolygon.loadNamedStyle( fileStyle ) self.mapCanvasEffects.zoom( self.layerPolygon, dataResult['geomBBox'] ) self.msgBar.clearWidgets() if exception: self.msgBar.pushMessage( self.nameModulus, str( exception ), Qgis.Critical ) return self.msgBar.pushMessage( self.nameModulus, dataResult['message'], dataResult['level'] ) if 'getFeatures' == dataResult['process']: endEditable() imgs = filter( lambda f: os.path.exists( f ), ( self.pathfileImage, self.pathfileImageSelect ) ) [ os.remove( item ) for item in imgs ] if dataResult['isOk']: setRenderLayer() self.setEnabledWidgetTransfer( True, True ) else: self.setEnabledWidgetTransfer( True ) else: self.setEnabledWidgetTransfer( True ) def run(task, data): self.worker.setData( task, data ) return self.worker.run() self.setEnabledWidgetTransfer( False ) task = QgsTask.fromFunction('GimpSelectionFeature Task', run, dataRun, on_finished=finished ) if not self.layerPolygon is None: task.setDependentLayers( [ self.layerPolygon ] ) self.taskManager.addTask( task )
def testTaskFromFunctionFinishedWithMultipleValues(self): """ test that task from function can have callback finished function and is passed multiple result values""" result_value = None result_statement = None def finished_multiple_value_result(e, results): nonlocal result_value nonlocal result_statement assert e is None result_value = results[0] result_statement = results[1] task = QgsTask.fromFunction('test task', run_multiple_val_result, on_finished=finished_multiple_value_result) QgsApplication.taskManager().addTask(task) while task.status() not in [QgsTask.Complete, QgsTask.Terminated]: pass while QgsApplication.taskManager().countActiveTasks() > 0: QCoreApplication.processEvents() # check that the finished function was called self.assertEqual(task.returned_values, (5, 'whoo')) self.assertFalse(task.exception) self.assertEqual(result_value, 5) self.assertEqual(result_statement, 'whoo')
def report_per_field(self): """Creates a QgsTask in order to collect data then on finish it runs simple_field.""" if self.path is None: QMessageBox.information( None, self.tr('Error'), self.tr('A directory to save the report must be selected.')) return year = self.dw.DEReportYear.text() if self.dw.RBReportWithoutDetails.isChecked(): self.report_name = '{p}\\{t}_{y}.pdf'.format( p=self.path, t=self.tr('GeoDataFarm_Limited_report'), y=year) if self.dw.RBAllYear.isChecked(): year = None else: year = self.dw.DEReportYear.text() task = QgsTask.fromFunction('Run import text data', self.collect_data, year, on_finished=self.simple_field) self.tsk_mngr.addTask(task) else: report_name = '{p}\\{t}_{y}.pdf'.format( p=self.path, t=self.tr('GeoDataFarm_Limited_report'), y=year)
def SaveACSV(self): """ Save Table as CSV """ data = self.player.GetPacketData() out, _ = askForFiles( self, QCoreApplication.translate("QgsFmvMetadata", "Save CSV"), isSave=True, exts="csv", ) if not out: return task = QgsTask.fromFunction( "Save CSV Report Task", self.CreateCSV, out=out, data=data, VManager=self.VManager, on_finished=self.finishedTask, flags=QgsTask.CanCancel, ) QgsApplication.taskManager().addTask(task) return
def testTaskFromFunctionCanceledWhileQueued(self): """ test that task from finished is called with exception when task is terminated while queued""" finished_exception = None def finished_fail(e): nonlocal finished_exception assert e finished_exception = e task = QgsTask.fromFunction('test task', run_no_result, on_finished=finished_fail) task.hold() QgsApplication.taskManager().addTask(task) task.cancel() while task.status() not in [QgsTask.Complete, QgsTask.Terminated]: pass while QgsApplication.taskManager().countActiveTasks() > 0: QCoreApplication.processEvents() # check that the finished function was called self.assertTrue(task.exception) self.assertTrue(finished_exception) self.assertEqual(task.exception, finished_exception)
def testExecuteSqlCancel(self): """Test that feedback can cancel an executeSql query""" if hasattr(self, 'slowQuery'): md = QgsProviderRegistry.instance().providerMetadata( self.providerKey) conn = md.createConnection(self.uri, {}) feedback = QgsFeedback() def _run(task): conn.executeSql(self.slowQuery, feedback=feedback) def _cancel(): feedback.cancel() start = time.time() QtCore.QTimer.singleShot(500, _cancel) task = QgsTask.fromFunction('test long running query', _run) QgsApplication.taskManager().addTask(task) while task.status() not in [QgsTask.Complete, QgsTask.Terminated]: QgsApplication.processEvents() end = time.time() self.assertTrue(end - start < 1)
def georeferencingVideo(parent): """Extract Current Frame Thread :param packet: Parent class """ image = parent.videoWidget.currentFrame() folder = getVideoFolder(parent.fileName) qgsu.createFolderByName(folder, "mosaic") out = os.path.join(folder, "mosaic") position = str(parent.player.position()) taskGeoreferencingVideo = QgsTask.fromFunction( "Georeferencing Current Frame Task", GeoreferenceFrame, image=image, output=out, p=position, on_finished=parent.finishedTask, flags=QgsTask.CanCancel, ) QgsApplication.taskManager().addTask(taskGeoreferencingVideo) return
def __init__(self, desc, observer): QgsTask.__init__(self, desc, QgsTask.CanCancel) self.observer = observer self._continue = True self._interval = 2.5
def call_import_temps_task(self): self.taskWeather = QgsTask.fromFunction(u'QWeather', self.import_temps_task, on_finished=self.completed, wait_time=4) QgsApplication.taskManager().addTask(self.taskWeather)
def update_pic(self): """Collects the data that the user gave as input and starts the QgsTask that runs the SQL query. On finish plot_data is called""" if self.canvas is not None: self.dlg.mplvl.removeWidget(self.canvas) if self.dlg.CBLimitArea.isChecked() and self.search_area == '': try: self.iface.actionSaveActiveLayerEdits().trigger() self.iface.actionToggleEditing().trigger() feature = self.add_field.field.getFeature(1) QgsProject.instance().removeMapLayer(self.add_field.field.id()) self.add_field.field = None except: QMessageBox.information( None, self.tr("Error:"), self. tr('No coordinates where found, did you mark the field on the canvas?' )) return limiting_polygon = feature.geometry().asWkt() self.search_area = limiting_polygon elif self.dlg.CBLimitArea.isChecked( ) and self.add_field.field is not None: self.iface.actionSaveActiveLayerEdits().trigger() self.iface.actionToggleEditing().trigger() feature = self.add_field.field.getFeature(1) QgsProject.instance().removeMapLayer(self.add_field.field.id()) self.add_field.field = None limiting_polygon = feature.geometry().asWkt() self.search_area = limiting_polygon elif self.dlg.CBLimitArea.isChecked(): limiting_polygon = self.search_area else: limiting_polygon = None self.search_area = '' other_parameters = {} investigating_param = {} investigating_param['values'] = [] prefixes = {} prefix_count = 0 for nbr, col in enumerate(self.layout_dict.keys()): self.update_top_panel(nbr, col) for tbl_nr in range(len(self.layout_dict[col]['tbl'])): table = self.layout_dict[col]['tbl'][tbl_nr] schema = self.layout_dict[col]['schema'][tbl_nr] data_type = self.layout_dict[col]['type'] ha = self.layout_dict[col]['harvest'][tbl_nr]['tbl_name'] s_t = '{schema}.{table}'.format(schema=schema, table=table) if s_t not in prefixes.keys(): prefix_count += 1 prefixes[s_t] = 'a{prefix_count}'.format( prefix_count=prefix_count) if self.cb[nbr].isChecked(): column_investigated = col if ha not in investigating_param.keys(): investigating_param[ha] = {} investigating_param[ha]['ha_col'] = \ self.layout_dict[col]['harvest'][tbl_nr]['index_col'] if s_t not in investigating_param[ha].keys(): investigating_param[ha][s_t] = {} investigating_param[ha][s_t] = {} investigating_param[ha][s_t]['prefix'] = prefixes[s_t] investigating_param[ha][s_t]['col'] = col i_col = col analyse_params = self.get_initial_distinct_values( col, table, schema) investigating_param['values'].extend( analyse_params['distinct_values']) # Can happens multiple times, hence shouldn't be a problem. if data_type == 'checked': investigating_param['checked'] = True else: investigating_param['checked'] = False else: if ha not in other_parameters.keys(): other_parameters[ha] = {} if s_t not in other_parameters[ha].keys(): other_parameters[ha][s_t] = {} other_parameters[ha][s_t]['prefix'] = prefixes[s_t] other_parameters[ha][s_t][col] = {} if self.layout_dict[col]['type'] == 'max_min': other_parameters[ha][s_t][col]['type'] = 'max_min' other_parameters[ha][s_t][col][ 'min'] = self.layout_dict[col]['min'] other_parameters[ha][s_t][col][ 'max'] = self.layout_dict[col]['max'] else: other_parameters[ha][s_t][col]['type'] = 'checked' other_parameters[ha][s_t][col]['check_text'] = "'" if not investigating_param['checked']: minvalue = float(self.layout_dict[i_col]['min']) maxvalue = float(self.layout_dict[i_col]['max']) values = copy.deepcopy(investigating_param['values']) for value in investigating_param['values']: if value is None: values.remove(value) elif round(value, 3) < minvalue: values.remove(value) elif round(value, 3) > maxvalue: values.remove(value) investigating_param['values'] = values if not investigating_param['checked'] and len( investigating_param['values']) > 20: investigating_param['hist'] = True investigating_param['values'].sort() temp = [] for val in range( 0, len(investigating_param['values']), int(round(len(investigating_param['values']) / 20))): temp.append(investigating_param['values'][val]) temp.append(investigating_param['values'][-1]) investigating_param['values'] = temp elif not investigating_param['checked']: investigating_param['hist'] = False investigating_param['values'].sort() else: investigating_param['hist'] = False investigating_param['values'] = "'" other_parameters, investigating_param = self.update_checked_field( other_parameters, investigating_param) min_counts = self.dlg.minNumber.text() self.column_investigated = column_investigated self.investigating_param = investigating_param task1 = QgsTask.fromFunction('running script', sql_query, investigating_param, other_parameters, self.db, min_counts, limiting_polygon, on_finished=self.plot_data) self.tsk_mngr.addTask(task1)
def run_waiting(self): waiting_msg = WaitingMsg() task = QgsTask.fromFunction('waiting', waiting_msg.run) self.tsk_mngr.addTask(task)
def createTaskCalcIntersects(self): taskManager = QgsApplication.taskManager() self.task1 = QgsTask.fromFunction(self.MESSAGE_CATEGORY, self.calcIntersects, on_finished=self.completed) taskManager.addTask(self.task1)
def call_import_photos(self): self.taskPhotos = QgsTask.fromFunction(u'ImportPhotos', self.import_photos_task, on_finished=self.completed, wait_time=4) QgsApplication.taskManager().addTask(self.taskPhotos)
def updateFeatures(self): def addExpField(expField): field = QgsField(expField, QVariant.String) sq, iniBraces, endBraces = "'{}" value = self._frm_url for c in 'xyzq': src = f"{iniBraces}{c}{endBraces}" dest = f"{sq} || {c} || {sq}" value = value.replace(src, dest) end_sq = f" || {sq}" if value.endswith(end_sq): total = -1 * (len(end_sq)) value = f"{sq}" + value[:total] else: value = f"{sq}{value}{sq}" self._layer.addExpressionField(value, field) def run(task, prov): totalTiles = self.getTotalTiles() c_tiles = 0 for tile in self._tilesCanvas(self._zoom): if task.isCanceled(): return {'canceled': True, 'total': c_tiles} feat = QgsFeature() geom = QgsGeometry.fromRect(tile.rect) feat.setGeometry(geom) feat.setAttributes([tile.x, tile.y, tile.z, tile.q]) prov.addFeature(feat) progress = c_tiles / totalTiles * 100 task.setProgress(progress) c_tiles += 1 return {'canceled': False, 'total': c_tiles} def finished(exception, result=None): self.selectedFeatures.emit(0) self._layer.updateExtents() self._layer.triggerRepaint() self._currentTask = None r = {'name': 'update'} if exception: r['error'] = f"Exception, {exception}" r.update(result) self.finishProcess.emit(r) if self._currentTask: self._currentTask.cancel() return prov = self._layer.dataProvider() prov.truncate() # Delete all expField = 'url' idExpField = self._layer.fields().indexOf(expField) if idExpField > -1: self._layer.removeExpressionField(idExpField) if self._frm_url: addExpField(expField) # Task self.finishedTask = False args = { 'description': f"{self.__class__.__name__}.populate", 'function': run, 'prov': prov, 'on_finished': finished } self._currentTask = QgsTask.fromFunction(**args) self._currentTask.setDependentLayers([self._layer]) self.taskManager.addTask(self._currentTask)
def CreateBitratePlot(self): ''' Create video Plot Bitrate Thread ''' sender = self.sender().objectName() if sender == "actionAudio": taskactionAudio = QgsTask.fromFunction( 'Show Audio Bitrate', self.BitratePlot.CreatePlot, fileName=self.fileName, output=None, t='audio', on_finished=self.finishedTask, flags=QgsTask.CanCancel) QgsApplication.taskManager().addTask(taskactionAudio) elif sender == "actionVideo": taskactionVideo = QgsTask.fromFunction( 'Show Video Bitrate', self.BitratePlot.CreatePlot, fileName=self.fileName, output=None, t='video', on_finished=self.finishedTask, flags=QgsTask.CanCancel) QgsApplication.taskManager().addTask(taskactionVideo) elif sender == "actionSave_Audio": fileaudio, _ = askForFiles(self, QCoreApplication.translate( "QgsFmvPlayer", "Save Audio Bitrate Plot"), isSave=True, exts=[ "png", "pdf", "pgf", "eps", "ps", "raw", "rgba", "svg", "svgz" ]) if not fileaudio: return taskactionSave_Audio = QgsTask.fromFunction( 'Save Action Audio Bitrate', self.BitratePlot.CreatePlot, fileName=self.fileName, output=fileaudio, t='audio', on_finished=self.finishedTask, flags=QgsTask.CanCancel) QgsApplication.taskManager().addTask(taskactionSave_Audio) elif sender == "actionSave_Video": filevideo, _ = askForFiles(self, QCoreApplication.translate( "QgsFmvPlayer", "Save Video Bitrate Plot"), isSave=True, exts=[ "png", "pdf", "pgf", "eps", "ps", "raw", "rgba", "svg", "svgz" ]) if not filevideo: return taskactionSave_Video = QgsTask.fromFunction( 'Save Action Video Bitrate', self.BitratePlot.CreatePlot, fileName=self.fileName, output=filevideo, t='video', on_finished=self.finishedTask, flags=QgsTask.CanCancel) QgsApplication.taskManager().addTask(taskactionSave_Video)
def convertVideo(self): '''Convert Video To Other Format ''' out, _ = askForFiles(self, QCoreApplication.translate( "QgsFmvPlayer", "Save Video as..."), isSave=True, exts=[ "mp4", "ogg", "avi", "mkv", "webm", "flv", "mov", "mpg", "mp3" ]) if not out: return # TODO : Make Correct format Conversion and embebed metadata info = self.converter.probeInfo(self.fileName) if info is not None: if self.HasFileAudio: audio_codec = info.audio.codec audio_samplerate = info.audio.audio_samplerate audio_channels = info.audio.audio_channels video_codec = info.video.codec video_width = info.video.video_width video_height = info.video.video_height video_fps = info.video.video_fps _, out_ext = os.path.splitext(out) if self.HasFileAudio: options = { 'format': out_ext[1:], 'audio': { 'codec': audio_codec, 'samplerate': audio_samplerate, 'channels': audio_channels }, 'video': { 'codec': video_codec, 'width': video_width, 'height': video_height, 'fps': video_fps } } else: options = { 'format': out_ext[1:], 'video': { 'codec': video_codec, 'width': video_width, 'height': video_height, 'fps': video_fps } } taskConvertVideo = QgsTask.fromFunction('Converting Video Task', self.converter.convert, infile=self.fileName, outfile=out, options=options, twopass=False, on_finished=self.finishedTask, flags=QgsTask.CanCancel) QgsApplication.taskManager().addTask(taskConvertVideo)
def cancel(self): self.con.cancel( ) #psycopg2 conection can be cancelled from any thread. QgsTask.cancel(self)
def __init__(self, desc, sourcePath, destGroup): QgsTask.__init__(self, desc) self.sourcePath = sourcePath self.destGroup = destGroup
def trigger_insection(self): """Preparing the data, by setting the correct type (including the date and time format), creating a shp file and finally ensure that the coordinates is in EPSG:4326 """ params = {} params['schema'] = self.data_type params['column_types'] = self.col_types params['heading_row'] = [] for col in self.heading_row: params['heading_row'].append(check_text(col)) params['encoding'] = self.encoding params['file_name_with_path'] = self.file_name_with_path params['field'] = self.ITD.CBField.currentText() params['longitude_col'] = self.longitude_col params['latitude_col'] = self.latitude_col params['focus_col'] = [] if self.ITD.RBDateOnly.isChecked(): is_ok, first_date = check_date_format( self.sample_data, check_text(self.ITD.ComBDate.currentText()), self.ITD.ComBDate_2.currentText()) if not is_ok: QMessageBox.information( None, self.tr('Error'), self. tr("The date format didn't match the selected format, please change" )) return params['date_row'] = check_text(self.ITD.ComBDate.currentText()) params['date_format'] = self.ITD.ComBDate_2.currentText() params['all_same_date'] = '' manual_date = 'date_' table_date = first_date else: params['all_same_date'] = self.ITD.DE.text() manual_date = 'c_' + self.ITD.DE.text() table_date = self.ITD.DE.text() params['date_row'] = '' self.tbl_name = check_text(self.ITD.CBField.currentText() + '_' + self.data_type + '_' + table_date) params['tbl_name'] = self.tbl_name if self.db.check_table_exists(self.tbl_name, self.data_type): return for i in range(self.add_to_param_row_count): params['focus_col'].append( check_text(self.ITD.TWtoParam.item(i, 0).text())) self.focus_cols = params['focus_col'] if params['schema'] == 'harvest': params['yield_row'] = params['focus_col'][0] params['max_yield'] = float(self.ITD.LEMaximumYield.text()) params['min_yield'] = float(self.ITD.LEMinimumYield.text()) self.mff.insert_manual_data(manual_date, self.ITD.CBField.currentText(), self.tbl_name, self.data_type) params['sep'] = self.sep params['tr'] = self.tr params['epsg'] = self.ITD.LEEPSG.text() if float(self.ITD.LEMoveX.text()) != 0.0 or float( self.ITD.LEMoveY.text()) != 0.0: params['move'] = True params['move_x'] = float(self.ITD.LEMoveX.text()) params['move_y'] = float(self.ITD.LEMoveY.text()) else: params['move'] = False #a = insert_data_to_database('debug', self.db, params) #print(a) task = QgsTask.fromFunction('Run import text data', insert_data_to_database, self.db, params, on_finished=self.finish) self.tsk_mngr.addTask(task)
def __init__(self, desc): QgsTask.__init__(self, desc)
def test_flags(self): """ Test task flags """ thread_safe_alg = QgsApplication.processingRegistry().algorithmById( 'native:buffer') nonthread_safe_alg = QgsApplication.processingRegistry().algorithmById( 'native:setprojectvariable') context = QgsProcessingContext() context.setProject(QgsProject.instance()) feedback = ConsoleFeedBack() task = QgsProcessingAlgRunnerTask(thread_safe_alg, {}, context=context, feedback=feedback) self.assertEqual(task.flags(), QgsTask.CanCancel) task = QgsProcessingAlgRunnerTask(thread_safe_alg, {}, context=context, feedback=feedback, flags=QgsTask.Flags()) self.assertEqual(task.flags(), QgsTask.Flags()) task = QgsProcessingAlgRunnerTask(thread_safe_alg, {}, context=context, feedback=feedback, flags=QgsTask.CanCancel) self.assertEqual(task.flags(), QgsTask.CanCancel) task = QgsProcessingAlgRunnerTask(thread_safe_alg, {}, context=context, feedback=feedback, flags=QgsTask.CancelWithoutPrompt) self.assertEqual(task.flags(), QgsTask.CancelWithoutPrompt) task = QgsProcessingAlgRunnerTask(thread_safe_alg, {}, context=context, feedback=feedback, flags=QgsTask.CancelWithoutPrompt | QgsTask.CanCancel) self.assertEqual(task.flags(), QgsTask.CancelWithoutPrompt | QgsTask.CanCancel) # alg which can't be canceled task = QgsProcessingAlgRunnerTask(nonthread_safe_alg, {}, context=context, feedback=feedback) self.assertEqual(task.flags(), QgsTask.Flags()) # we clear the CanCancel flag automatically, since the algorithm itself cannot be canceled task = QgsProcessingAlgRunnerTask(nonthread_safe_alg, {}, context=context, feedback=feedback, flags=QgsTask.CanCancel) self.assertEqual(task.flags(), QgsTask.Flags()) # hidden task task = QgsProcessingAlgRunnerTask(thread_safe_alg, {}, context=context, feedback=feedback, flags=QgsTask.Hidden) self.assertEqual(task.flags(), QgsTask.Hidden) task = QgsProcessingAlgRunnerTask(thread_safe_alg, {}, context=context, feedback=feedback, flags=QgsTask.Hidden | QgsTask.CanCancel) self.assertEqual(task.flags(), QgsTask.Hidden | QgsTask.CanCancel) task = QgsProcessingAlgRunnerTask(thread_safe_alg, {}, context=context, feedback=feedback, flags=QgsTask.Hidden | QgsTask.CanCancel | QgsTask.CancelWithoutPrompt) self.assertEqual( task.flags(), QgsTask.Hidden | QgsTask.CanCancel | QgsTask.CancelWithoutPrompt) task = QgsProcessingAlgRunnerTask(nonthread_safe_alg, {}, context=context, feedback=feedback, flags=QgsTask.Hidden) self.assertEqual(task.flags(), QgsTask.Hidden) task = QgsProcessingAlgRunnerTask(nonthread_safe_alg, {}, context=context, feedback=feedback, flags=QgsTask.Hidden | QgsTask.CanCancel) self.assertEqual(task.flags(), QgsTask.Hidden)
def prepareXsdForMetadata(self): task = QgsTask.fromFunction('Wczytywanie schematu XSD dla metadanych', self.createMetadataValidator) if task.description() not in [task.description() for task in QgsApplication.taskManager().activeTasks()]: QgsApplication.taskManager().addTask(task) QgsMessageLog.logMessage('starting XSD reading task')