def test_methodinvoke(self):
executor = ThreadExecutor()
state = [None, None]
class StateSetter(QObject):
@Slot(object)
def set_state(self, value):
state[0] = value
state[1] = QThread.currentThread()
def func(callback):
callback(QThread.currentThread())
obj = StateSetter()
f1 = executor.submit(func, methodinvoke(obj, "set_state", (object, )))
f1.result()
# So invoked method can be called
QCoreApplication.processEvents()
self.assertIs(state[1], QThread.currentThread(),
"set_state was called from the wrong thread")
self.assertIsNot(state[0], QThread.currentThread(),
"set_state was invoked in the main thread")
executor.shutdown(wait=True)
def popUp(self):
"""Popup from the tray"""
# Reposition the window
r = QDesktopWidget().availableGeometry()
s = self.size()
pos = getConfig("pos")
if pos == "Top right":
x = r.left() + r.width() - s.width()
y = r.top()
elif pos == "Top left":
x = r.left()
y = r.top()
elif pos == "Bottom right":
x = r.left() + r.width() - s.width()
y = r.top() + r.height() - s.height()
elif pos == "Bottom left":
x = r.left()
y = r.top() + r.height() - s.height()
else:
x = r.left() + r.width() / 2 - s.width() / 2
y = r.top() + r.height() / 2 - s.height() / 2
self.move(x, y)
# Show it
self.show()
QCoreApplication.processEvents()
self.raise_()
self.activateWindow()
# Focus the search box
self.ui.lineEditQuery.selectAll()
self.ui.lineEditQuery.setFocus()
def refresh(self):
searches = self.projectFinder.searches
self.stop = False
self.cancelButton.show()
self.refreshButton.hide()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(
len(searches) * 100) # progressBar only accepts int, so scaling
self.progressBar.show()
unRecorded = self.unrecordedCheckBox.isChecked()
onlySelected = self.selectionComboBox.currentIndex() == 1
unEvaluated = self.unevaluatedCheckBox.isChecked()
unEvaluatedDelay = self.unevalutedDaysSpinBox.value()
removeDeleted = self.deletedLayersCheckBox.isChecked()
limit_date = nDaysAgoIsoDate(unEvaluatedDelay)
self.searchProgress = -1
for search in searches.values():
QCoreApplication.processEvents()
self.searchProgress += 1
self.currentLayerLength = 0
self.setProgress()
# user stop
if self.stop:
break
# delete search if layer has been deleted
layer = search.layer()
if layer is None and removeDeleted:
if self.projectSearchModel is not None:
self.projectSearchModel.removeSearches([search.searchId])
else:
self.projectFinder.deleteSearch(search.searchId)
continue
# if specified do not process recently evaluated search
if unEvaluated and search.dateEvaluated >= limit_date:
continue
# if specified only process non evaluated searches
if unRecorded and search.dateEvaluated is not None:
continue
# if specified only do selected rows
if onlySelected and self.selectedRows is not None:
if search.searchId not in self.selectedRows:
continue
self.currentLayerLength = layer.featureCount()
ok, message = self.projectFinder.recordSearch(search)
self.progressBar.hide()
self.cancelButton.hide()
self.refreshButton.show()
def search(self):
if self.running:
return
toFind = self.lineEdit().text()
if not toFind or toFind == '':
return
self.running = True
self.searchStarted.emit()
self.clearSelection()
self.resultModel.clearResults()
self.resultModel.truncateHistory(MySettings().value("historyLength"))
self.resultModel.setLoading(True)
self.showPopup()
QCoreApplication.processEvents(QEventLoop.ExcludeUserInputEvents)
self.findersToStart = []
for finder in self.finders.values():
if finder.activated():
self.findersToStart.append(finder)
bbox = self.mapCanvas.fullExtent()
while len(self.findersToStart) > 0:
finder = self.findersToStart[0]
self.findersToStart.remove(finder)
self.resultModel.addResult(finder.name)
finder.start(toFind, bbox=bbox)
# For case there is no finder activated
self.finished(None)
def run(self, gc, rawFile, pointFile, geoFile):
self._step = Georeferencer.Start
if (not gc.isValid()):
self._signalError('Invalid ground control points.')
return
self._gc = gc
if (not rawFile.exists()):
self._signalError('Raw file not found.')
return
self._rawFile = rawFile
self._pointFile = pointFile
self._geoFile = geoFile
if not self._geoFile.absoluteDir().exists():
self._geoFile.absoluteDir().mkpath('.')
if (self._debug):
debug('Raw File: \'' + self._rawFile.absoluteFilePath() + '\'')
debug('GCP File: \'' + self._pointFile.absoluteFilePath() + '\'')
debug('Crop File: \'' + self._cropFile.absoluteFilePath() + '\'')
debug('Translate File: \'' +
self._translateFile.absoluteFilePath() + '\'')
debug('Geo File: \'' + self._geoFile.absoluteFilePath() + '\'')
QCoreApplication.processEvents()
self._runCropStep()
def printToRaster(self, cView, folder, name, ext):
"""Export to image raster."""
for numpage in range(0, cView.composition().numPages()):
if self.arret:
break
# process input events
QCoreApplication.processEvents()
# managing multiple pages in the composition
imgOut = cView.composition().printPageAsRaster(numpage)
if numpage == 0:
imgOut.save(os.path.join(folder, name + ext))
else:
imgOut.save(
os.path.join(folder, name + '_' + str(numpage + 1) + ext))
self.pageProcessed()
# Generating a worldfile if asked to
if hasattr(cView.composition(),
"generateWorldFile"): # not in qgis < 2.2
generatewf = cView.composition().generateWorldFile()
if generatewf:
wf = cView.composition().computeWorldFileParameters()
worldFileSuffix = ext[0:2] + ext[-1] + "w"
worldFileName = os.path.join(folder, name + worldFileSuffix)
with open(worldFileName, "w") as f:
f.write("%s\n\n" % wf[0])
f.write("%s\n\n" % wf[1])
f.write("%s\n\n" % wf[3])
f.write("%s\n\n" % wf[4])
f.write("%s\n\n" % wf[2])
f.write("%s\n" % wf[5])
def browser_itemclicked(self, fileinfo, newState):
"""
Triggered when an item in the browser is clicked.
"""
path = fileinfo.fullpath
if newState == False:
# Item was unchecked. Remove node(s)
if self.fileSystemItemToLegendNode.has_key(path):
nodes = self.fileSystemItemToLegendNode[path]
#print "Remove node", nodehandle
for nodeinfo in nodes:
node = self._getlayerTreeNode(nodeinfo)
if node:
try:
self.removingNode = True
node.parent().removeChildNode(node)
finally:
self.removingNode = False
self.fileSystemItemToLegendNode.pop(path, None)
else:
# Item was checked
if fileinfo.isdir:
pass
else:
msgWidget = self.iface.messageBar().createMessage(
u"Indlæser", fileinfo.displayname)
msgItem = self.iface.messageBar().pushWidget(
msgWidget, QgsMessageBar.INFO, duration=0)
# Force show messageBar
QCoreApplication.processEvents()
# Load file
self.load_qlr_file(path)
# Remove message
self.iface.messageBar().popWidget(msgItem)
def browser_itemclicked(self, fileinfo, newState):
"""
Triggered when an item in the browser is clicked.
"""
path = fileinfo.fullpath
if newState == False:
# Item was unchecked. Remove node(s)
if self.fileSystemItemToLegendNode.has_key(path):
nodes = self.fileSystemItemToLegendNode[path]
#print "Remove node", nodehandle
for nodeinfo in nodes:
node = self._getlayerTreeNode(nodeinfo)
if node:
try:
self.removingNode = True
node.parent().removeChildNode(node)
finally:
self.removingNode = False
self.fileSystemItemToLegendNode.pop(path, None)
else:
# Item was checked
if fileinfo.isdir:
pass
else:
msgWidget = self.iface.messageBar().createMessage(u"Indlæser", fileinfo.displayname)
msgItem = self.iface.messageBar().pushWidget(msgWidget, QgsMessageBar.INFO, duration=0)
# Force show messageBar
QCoreApplication.processEvents()
# Load file
self.load_qlr_file(path)
# Remove message
self.iface.messageBar().popWidget(msgItem)
def run_gridExtract(self):
"""Run method for the Grid Extract dialog"""
dlgGridExtract = GridExtractDialog(self.iface)
# Show the dialog
dlgGridExtract.show()
if dlgGridExtract.exec_():
output_file = dlgGridExtract.lneSaveCSVFile.text()
import webbrowser
try:
from urllib import pathname2url # Python 2.x
except:
from urllib.request import pathname2url # Python 3.x
def open_folder():
url = 'file:{}'.format(pathname2url(os.path.abspath(output_file)))
webbrowser.open(url)
message = 'Raster statistics for points extracted successfully !'
#add a button to open the file outside qgis
widget = self.iface.messageBar().createMessage('', message)
button = QPushButton(widget)
button.setText('Open File')
button.pressed.connect(open_folder)
widget.layout().addWidget(button)
self.iface.messageBar().pushWidget(widget, level=QgsMessageBar.SUCCESS, duration=15)
LOGGER.info(message)
# Close Dialog
dlgGridExtract.deleteLater()
# Refresh QGIS
QCoreApplication.processEvents()
def run_cleanTrimPoints(self):
"""Run method for cleanTrimPoints dialog"""
dlgCleanTrimPoints = CleanTrimPointsDialog(self.iface)
# show the dialog
dlgCleanTrimPoints.show()
if dlgCleanTrimPoints.exec_():
output_folder = os.path.dirname(dlgCleanTrimPoints.lneSaveCSVFile.text())
import webbrowser
try:
from urllib import pathname2url # Python 2.x
except:
from urllib.request import pathname2url # Python 3.x
def open_folder():
url = 'file:{}'.format(pathname2url(os.path.abspath(output_folder)))
webbrowser.open(url)
message = 'Cleaned and trimmed points successfully !'
widget = self.iface.messageBar().createMessage('', message)
button = QPushButton(widget)
button.setText('Open Folder')
button.pressed.connect(open_folder)
widget.layout().addWidget(button)
self.iface.messageBar().pushWidget(widget, level=QgsMessageBar.SUCCESS, duration=15)
LOGGER.info(message)
# Close Dialog
dlgCleanTrimPoints.deleteLater()
# Refresh QGIS
QCoreApplication.processEvents()
def start(self):
idx = self.pipeLayer.fieldNameIndex("_valve_closed")
pFeatReq = QgsFeatureRequest()
pipe = QgsFeature()
valve = QgsFeature()
pipeIterator = self.pipeLayer.getFeatures(pFeatReq)
k = 1
while pipeIterator.nextFeature(pipe) and self.goOn:
self.progress.emit(k)
closed = False
bbox = pipe.geometry().boundingBox()
vFeatReq = QgsFeatureRequest().setFilterRect(bbox)
valveIterator = self.valveLayer.getFeatures(vFeatReq)
while valveIterator.nextFeature(valve):
if valve["closed"] == 't':
if pipe.geometry().touches(valve.geometry()):
closed = True
break
self.pipeLayer.dataProvider().changeAttributeValues(
{pipe.id(): {
idx: closed
}})
k += 1
QCoreApplication.processEvents()
self.finished.emit()
def run_stripTrialPoints(self):
if parse_version(pyprecag.__version__) < parse_version('0.2.0'):
self.iface.messageBar().pushMessage(
"Create strip trial points tool is not supported in pyprecag {}. "
"Upgrade to version 0.2.0+".format(pyprecag.__version__),
level=QgsMessageBar.WARNING, duration=15)
return
"""Run method for the Strip trial points dialog"""
dlgStripTrialPoints = StripTrialPointsDialog(self.iface)
# Show the dialog
dlgStripTrialPoints.show()
if dlgStripTrialPoints.exec_():
message = 'Strip trial points created successfully !'
self.iface.messageBar().pushMessage(message, level=QgsMessageBar.SUCCESS, duration=15)
# LOGGER.info(message)
# Close Dialog
dlgStripTrialPoints.deleteLater()
# Refresh QGIS
QCoreApplication.processEvents()
def search(self):
if self.running:
return
toFind = self.lineEdit().text()
if not toFind or toFind == '':
return
self.running = True
self.searchStarted.emit()
self.resultModel.clearResults()
self.resultModel.truncateHistory(MySettings().value("historyLength"))
self.resultModel.setLoading(True)
self.showPopup()
QCoreApplication.processEvents(QEventLoop.ExcludeUserInputEvents)
# create categories in special order and count activated ones
for finder in self.finders.values():
if finder.activated():
self.resultModel.addResult(finder.name)
bbox = self.mapCanvas.fullExtent()
for finder in self.finders.values():
if finder.activated():
finder.start(toFind, bbox=bbox)
def test_methodinvoke(self):
executor = ThreadExecutor()
state = [None, None]
class StateSetter(QObject):
@Slot(object)
def set_state(self, value):
state[0] = value
state[1] = QThread.currentThread()
def func(callback):
callback(QThread.currentThread())
obj = StateSetter()
f1 = executor.submit(func, methodinvoke(obj, "set_state", (object,)))
f1.result()
# So invoked method can be called
QCoreApplication.processEvents()
self.assertIs(state[1], QThread.currentThread(),
"set_state was called from the wrong thread")
self.assertIsNot(state[0], QThread.currentThread(),
"set_state was invoked in the main thread")
executor.shutdown(wait=True)
def test_jrodos_project_url(self):
conf = JRodosProjectConfig()
#conf.url = 'https://duif.net/project1268.json'
#conf.url = 'http://jrodos.dev.cal-net.nl:8080/jrodos-rest-service/jrodos/projects/1268'
conf.url = 'http://geoserver.dev.cal-net.nl/rest/jrodos/projects/208'
#conf.url = 'http://geoserver.dev.cal-net.nl/rest-1.0-TEST-1/jrodos/projects/208'
prov = JRodosProjectProvider(conf)
def prov_finished(result):
# get first dataitem form first task from first project
#dataitems = result.data['project']['tasks'][0]['dataitems']
dataitems = result.data['tasks'][0]['dataitems']
self.assertEquals(575, len(dataitems))
# get first dataitem form first task from first project
#dataitems = result.data['project']['tasks'][0]['dataitems']
dataitems = result.data['tasks'][0]['dataitems']
self.assertEquals(575, len(dataitems))
one_item = dataitems[361]
unit = one_item['unit']
# on rest-1.0-TEST-1 we do not have units yet
#unitt = 'rO0ABXNyAB5qYXZheC5tZWFzdXJlLnVuaXQuUHJvZHVjdFVuaXQAAAAAAAAAAQIAAkkACV9oYXNoQ29kZVsACV9lbGVtZW50c3QAKVtMamF2YXgvbWVhc3VyZS91bml0L1Byb2R1Y3RVbml0JEVsZW1lbnQ7eHIAHmphdmF4Lm1lYXN1cmUudW5pdC5EZXJpdmVkVW5pdJ9leNEz2RhmAgAAeHIAF2phdmF4Lm1lYXN1cmUudW5pdC5Vbml0zcjeFnjNUmcCAAB4cAAAAAB1cgApW0xqYXZheC5tZWFzdXJlLnVuaXQuUHJvZHVjdFVuaXQkRWxlbWVudDscDCvnLvFoGAIAAHhwAAAAAnNyACZqYXZheC5tZWFzdXJlLnVuaXQuUHJvZHVjdFVuaXQkRWxlbWVudAAAAAAAAAABAgADSQAEX3Bvd0kABV9yb290TAAFX3VuaXR0ABlMamF2YXgvbWVhc3VyZS91bml0L1VuaXQ7eHAAAAABAAAAAXNyABtqYXZheC5tZWFzdXJlLnVuaXQuQmFzZVVuaXQAAAAAAAAAAQIAAUwAB19zeW1ib2x0ABJMamF2YS9sYW5nL1N0cmluZzt4cQB+AAN0AAFtc3EAfgAH/////wAAAAFzcQB+AAp0AAFz'
unitt = 'm/s'
self.assertEquals(unitt, unit)
prov.finished.connect(prov_finished)
prov.get_data()
while not prov.is_finished():
QCoreApplication.processEvents()
def setInfo(self, msg, error=False):
if error:
self.txtLog.append('<span style="color:red"><br>%s<br></span>' %
msg)
else:
self.txtLog.append(msg)
QCoreApplication.processEvents()
def progressEvent(theReceived, theTotal):
QCoreApplication.processEvents()
theProgressDlg.setLabelText("%s / %s" % (theReceived, theTotal))
theProgressDlg.setMaximum(theTotal)
theProgressDlg.setValue(theReceived)
def restart(self, num_processors=None, wait=False):
if num_processors is not None:
assert sum(num_processors) <= MAX_NUMBER_PROCESSORS, \
'total number of additional processors must be %d or less' % MAX_NUMBER_PROCESSORS
# stop new items from being processed
self.shutdown_processors()
# attempt to stop current processors
if self._local_file_thread is not None:
self._local_file_thread.worker.stop()
if self._local_folder_thread is not None:
self._local_folder_thread.worker.stop()
if self._remote_file_thread is not None:
self._remote_file_thread.worker.stop()
if self._remote_folder_thread is not None:
self._remote_folder_thread.worker.stop()
for p in self._processors_pool:
p.worker.stop()
if wait:
while self.is_active():
QCoreApplication.processEvents()
sleep(0.1)
self.set_max_processors(num_processors)
# re-enable new items to trigger processing
self.init_processors()
# launch processors for new items in the queue, if any
self.launch_processors()
def _load_page(self, url, width, height, timeout):
"""
This method implements the logic for retrieving and displaying
the requested page.
"""
# This is an event-based application. So we have to wait until
# "loadFinished(bool)" raised.
cancelAt = time.time() + timeout
self.__loadings = True
self.__loadingResult = False # Default
# TODO: fromEncoded() needs to be used in some situations. Some
# sort of flag should be passed in to WebkitRenderer maybe?
#self._page.mainFrame().load(QUrl.fromEncoded(url))
self._page.mainFrame().load(QUrl(url))
while self.__loadings:
if timeout > 0 and time.time() >= cancelAt:
raise RuntimeError("Request timed out on %s" % url)
while QApplication.hasPendingEvents():
QCoreApplication.processEvents()
LOG.debug("Processing result")
if self.__loading_result == False:
LOG.warning("Failed to load %s" % url)
# Set initial viewport (the size of the "window")
size = self._page.mainFrame().contentsSize()
LOG.debug("contentsSize: %s", size)
if width > 0:
size.setWidth(width)
if height > 0:
size.setHeight(height)
self._window.resize(size)
def run(self):
logging.debug('Collector thread started.')
last = time.time()
stop = self.stop
options = self.options
interval = options.interval * 60
self.session = session = Session(strategy=False)
session.filename = options.output
self.connect(session, Signals.session.status, logging.debug)
session.connectTWS(
options.host, options.port, options.clientid)
if not session.isConnected():
logging.error('Could not connect to %s:%s.',
options.host, options.port)
logging.error('Aborting.')
return
session.requestAccount()
while True:
now = time.time()
if stop is not None:
if stop < now:
break
self.sleep(1)
if last + interval < now:
session.save()
self.successful = True
last = now
QCoreApplication.processEvents()
QCoreApplication.processEvents()
logging.debug('Collector thread completed.')
def processEvents(self):
# hack copied from QgsVectorLayerInterruption.... .mustStop
# to allow responsive cancelation on linux
i = 0
while i < 100 and QCoreApplication.hasPendingEvents():
QCoreApplication.processEvents()
i += 1
def run(self):
logging.debug('Collector thread started.')
last = time.time()
stop = self.stop
options = self.options
interval = options.interval * 60
self.session = session = Session(strategy=False)
session.filename = options.output
self.connect(session, Signals.session.status, logging.debug)
session.connectTWS(options.host, options.port, options.clientid)
if not session.isConnected():
logging.error('Could not connect to %s:%s.', options.host,
options.port)
logging.error('Aborting.')
return
session.requestAccount()
while True:
now = time.time()
if stop is not None:
if stop < now:
break
self.sleep(1)
if last + interval < now:
session.save()
self.successful = True
last = now
QCoreApplication.processEvents()
QCoreApplication.processEvents()
logging.debug('Collector thread completed.')
def search(self):
if self.running:
return
toFind = self.lineEdit().text()
if not toFind or toFind == '':
return
self.running = True
self.searchStarted.emit()
self.clearSelection()
self.resultModel.clearResults()
self.resultModel.truncateHistory(MySettings().value("historyLength"))
self.resultModel.setLoading(True)
self.showPopup()
QCoreApplication.processEvents(QEventLoop.ExcludeUserInputEvents)
self.findersToStart = []
for finder in self.finders.values():
if finder.activated():
self.findersToStart.append(finder)
bbox = self.mapCanvas.fullExtent()
while len(self.findersToStart) > 0:
finder = self.findersToStart[0]
self.findersToStart.remove(finder)
self.resultModel.addResult(finder.name)
finder.start(toFind, bbox=bbox)
# For case there is no finder activated
self.finished(None)
def IntersectionGeometrie(listeGeometriesIn, listeGeometriesCut,
compteurEntre):
"""
en entrée
listeGeometriesIn = liste de géométries simples regroupées par dB ---> type list
listeGeometriesCut = liste de géométries simples pour découper ---> type list
compteurEntre = pour incrémentation de la barre de progression ---> type int
en sortie
listeGeometriesOut = cette même liste mais découpée par la deuxième ---> type list
compteurEntre = pour incrémentation de la barre de progression ---> type int
"""
listeGeometriesOut = []
for geometrieIn in listeGeometriesIn:
if geometrieIn.area() != 0:
for geometrieCut in listeGeometriesCut: #on découpe pour chaque geometrie
#vérification si l'utilisateur n'as pas demandé l'arret du traitement
if interfaceUtilisateur.ProgressBar.drapeauArretFonctionEnCours == True:
return (1, 1)
geom = geometrieIn.intersection(geometrieCut)
interfaceUtilisateur.ProgressBar.progressBarLocale.setValue(
compteurEntre)
QCoreApplication.processEvents()
compteurEntre = compteurEntre + 1
if geom.area() != 0:
listeGeometriesOut.append(geom)
else:
print "geom vide"
return (listeGeometriesOut, compteurEntre)
def popUp(self): """Popup from the tray""" # Reposition the window r = QDesktopWidget().availableGeometry() s = self.size() pos = getConfig(u"pos") if pos == u"Top right": x = r.left() + r.width()-s.width() y = r.top() elif pos == u"Top left": x = r.left() y = r.top() elif pos == u"Bottom right": x = r.left() + r.width()-s.width() y = r.top() + r.height()-s.height() elif pos == u"Bottom left": x = r.left() y = r.top() + r.height()-s.height() else: x = r.left() + r.width()/2 - s.width()/2 y = r.top() + r.height()/2 - s.height()/2 self.move(x, y) # Show it self.show() QCoreApplication.processEvents() self.raise_() self.activateWindow() # Focus the search box self.ui.lineEditQuery.selectAll() self.ui.lineEditQuery.setFocus()
def runCurrentStepFunction(self):
QCoreApplication.processEvents()
step = self.lesson.steps[self.currentStep]
self.webView.setEnabled(False)
step.function()
self.webView.setEnabled(True)
self.stepFinished()
def moveToNextStep(self):
if self.currentStep == len(self.lesson.steps):
dlg = LessonFinishedDialog(self.lesson)
dlg.exec_()
if dlg.nextLesson is not None:
self.init(dlg.nextLesson)
else:
self.finishLesson()
else:
step = self.lesson.steps[self.currentStep]
if step.endsignal is not None:
step.endsignal.connect(self.endSignalEmitted)
item = self.listSteps.item(self.currentStep)
item.setBackground(Qt.green)
if os.path.exists(step.description):
with open(step.description) as f:
html = "".join(f.readlines())
self.webView.document().setMetaInformation(QTextDocument.DocumentUrl,
QUrl.fromUserInput(step.description).toString())
self.webView.setHtml(html)
else:
self.webView.setHtml(step.description)
QCoreApplication.processEvents()
if step.prestep is not None:
execute(step.prestep)
if step.function is not None:
self.btnRunStep.setEnabled(step.steptype != Step.AUTOMATEDSTEP)
self.btnMove.setEnabled(step.steptype != Step.AUTOMATEDSTEP and step.endsignal is None)
if step.steptype == Step.AUTOMATEDSTEP:
self.runCurrentStepFunction()
else:
self.btnRunStep.setEnabled(False)
self.btnMove.setEnabled(step.endsignal is None)
def progressEvent(theReceived, theTotal):
QCoreApplication.processEvents()
theProgressDlg.setLabelText("%s / %s" % (theReceived, theTotal))
theProgressDlg.setMaximum(theTotal)
theProgressDlg.setValue(theReceived)
def refresh(self):
searches = self.projectFinder.searches
self.stop = False
self.cancelButton.show()
self.refreshButton.hide()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(len(searches)*100) # progressBar only accepts int, so scaling
self.progressBar.show()
unRecorded = self.unrecordedCheckBox.isChecked()
onlySelected = self.selectionComboBox.currentIndex() == 1
unEvaluated = self.unevaluatedCheckBox.isChecked()
unEvaluatedDelay = self.unevalutedDaysSpinBox.value()
removeDeleted = self.deletedLayersCheckBox.isChecked()
limit_date = nDaysAgoIsoDate(unEvaluatedDelay)
self.searchProgress = -1
for search in searches.values():
QCoreApplication.processEvents()
self.searchProgress += 1
self.currentLayerLength = 0
self.setProgress()
# user stop
if self.stop:
break
# delete search if layer has been deleted
layer = search.layer()
if layer is None and removeDeleted:
if self.projectSearchModel is not None:
self.projectSearchModel.removeSearches([search.searchId])
else:
self.projectFinder.deleteSearch(search.searchId)
continue
# if specified do not process recently evaluated search
if unEvaluated and search.dateEvaluated >= limit_date:
continue
# if specified only process non evaluated searches
if unRecorded and search.dateEvaluated is not None:
continue
# if specified only do selected rows
if onlySelected and self.selectedRows is not None:
if search.searchId not in self.selectedRows:
continue
self.currentLayerLength = layer.featureCount()
ok, message = self.projectFinder.recordSearch(search)
self.progressBar.hide()
self.cancelButton.hide()
self.refreshButton.show()
def tearDown(self):
if self.app.dialog:
QCoreApplication.processEvents()
self.app.dialog.done(0)
QCoreApplication.processEvents()
shutil.rmtree(self.report_dir)
shutil.rmtree(self.hook_dir)
def get_data(self):
url = self.config.url
request = QUrl(url)
reply = self.network_manager.get(QNetworkRequest(request))
reply.finished.connect(partial(self.data_retrieved, reply))
# this part is needed to be sure we do not return immidiatly
while not reply.isFinished():
QCoreApplication.processEvents()
def set_progress_bar(self, value):
"""Set progress bar value.
:param value: integer value for progress bar
:type value: int
"""
self.progress_bar.setValue(value)
QCoreApplication.processEvents()
def tearDown(self):
if self.app.dialog:
QCoreApplication.processEvents()
self.app.dialog.done(0)
QCoreApplication.processEvents()
shutil.rmtree(self.report_dir)
shutil.rmtree(self.hook_dir)
def syncfinsihed(self, down, up, errors):
errormessage = _pluralstring("Error", len(errors))
message = "Total Downloaded: {0}\nTotal Uploaded: {1}\n{2}".format(down,up, errormessage)
self.ui.statusLabel.setText(message)
self.ui.header.setText("Sync complete")
self.ui.buttonBox.setEnabled(True)
QCoreApplication.processEvents()
def doSearchGme(self):
"""Show the search dialog."""
self.iface.messageBar().pushMessage(
'Google Maps Engine Connector', 'Fetching maps. Please wait...',
level=QgsMessageBar.INFO)
QCoreApplication.processEvents()
searchGmeDialog = search_gme_dialog.Dialog(self.iface)
searchGmeDialog.exec_()
def parseDirectories(Directories):
TailNames = []
for d in Directories:
QCoreApplication.processEvents()
d = str(d)
head, tail = os.path.split(d)
TailNames.append(tail)
return TailNames
def waitUntilFinished(self):
"""
Processes the main thread until the loading process has finished. This
is a way to force the main thread to be synchronous in its execution.
"""
QCoreApplication.processEvents()
while self.isLoading():
QCoreApplication.processEvents()
def _sequencerControl(self):
button = eval("self.mw.seqControl")
button.setEnabled(False)
QCoreApplication.processEvents()
for x in xrange(1, len(self.steps)+1):
self._loadStep(x)
sleep(float(self.steps[x-1].time)/1000)
button.setEnabled(True)
def setup_ui(self):
self.zparent.comboBox_2.setDisabled(True)
self.zparent.extract_btn.setDisabled(True)
QCoreApplication.processEvents()
self.zparent.browse_bpl.clicked.connect(self.browse_bpl_file)
self.zparent.comboBox_3.currentIndexChanged.connect(
self.select_bpl_formats)
self.zparent.checkBox.stateChanged.connect(self.select_bpl_color)
def run_about(self):
"""Run method for the about dialog"""
dlgAbout = AboutDialog()
if dlgAbout.exec_():
pass
dlgAbout.deleteLater()
# Refresh QGIS
QCoreApplication.processEvents()
def chapter_rendered(self, num):
if num > 0:
self.progress_bar.setMinimum(0)
self.progress_bar.setMaximum(num)
self.progress_bar.setValue(0)
self.progress_label.setText('Laying out ' + self.document_title)
else:
self.progress_bar.setValue(self.progress_bar.value() + 1)
QCoreApplication.processEvents()
def chapter_rendered(self, num):
if num > 0:
self.progress_bar.setMinimum(0)
self.progress_bar.setMaximum(num)
self.progress_bar.setValue(0)
self.progress_label.setText('Laying out '+ self.document_title)
else:
self.progress_bar.setValue(self.progress_bar.value()+1)
QCoreApplication.processEvents()
def _interact(self):
QCoreApplication.processEvents()
# Handle thread pause
while (self._pause and self._continue):
QCoreApplication.processEvents()
sleep(0.01)
# Handle thread interruption
if not self._continue:
raise ThreadInterrupt()
def flush(self, error=False, prompt=False):
"""Flush buffer, write text to console"""
text = "".join(self.__buffer)
self.__buffer = []
self.insert_text(text, at_end=True, error=error, prompt=prompt)
QCoreApplication.processEvents()
self.repaint()
# Clear input buffer:
self.new_input_line = True
def syncstatus(self, layer, changes):
# ewww
if changes == 0:
return
changemessage = _pluralstring("change", changes)
message = "Updated layer {0} with {1}".format(layer, changemessage)
self.ui.updatestatus.addItem(message)
QCoreApplication.processEvents()
def test_calnet_measurements_quantities(self):
def prov_finished(result):
# TODO some better testing here
# [{'code': 'ZR-97', 'description': 'ZIRCONIUM-97 (ZR-97)'}, ...
print result
self.prov.finished.connect(prov_finished)
self.prov.get_data('Quantities')
while not self.prov.is_finished():
QCoreApplication.processEvents()
def test_calnet_measurements_units(self):
def prov_finished(result):
# TODO some better testing here
# [{'code': ' ', 'description': 'BLANKFIELD ( )'}, {'code': '%', 'description': 'PERCENTAGE (%)'},
print result
self.prov.finished.connect(prov_finished)
self.prov.get_data('Units')
while not self.prov.is_finished():
QCoreApplication.processEvents()
def run(self):
logging.debug('Wait thread started.')
while True:
now = time.time()
if self.when < now:
logging.debug('Wait thread completed.')
return
self.sleep(1)
QCoreApplication.processEvents()
def run(self):
logging.debug('Wait thread started.')
while True:
now = time.time()
if self.when < now:
logging.debug('Wait thread completed.')
return
self.sleep(1)
QCoreApplication.processEvents()
def _interact(self):
QCoreApplication.processEvents()
# Handle thread pause
while (self._pause and self._continue):
QCoreApplication.processEvents()
sleep(0.01)
# Handle thread interruption
if not self._continue:
raise ThreadInterrupt()
class TestTask(unittest.TestCase):
def setUp(self):
self.app = QCoreApplication([])
def test_task(self):
results = []
task = Task(function=QThread.currentThread)
task.resultReady.connect(results.append)
task.start()
self.app.processEvents()
self.assertSequenceEqual(results, [QThread.currentThread()])
results = []
thread = QThread()
thread.start()
task = Task(function=QThread.currentThread)
task.moveToThread(thread)
self.assertIsNot(task.thread(), QThread.currentThread())
self.assertIs(task.thread(), thread)
task.resultReady.connect(results.append, Qt.DirectConnection)
task.start()
f = task.future()
self.assertIsNot(f.result(3), QThread.currentThread())
self.assertIs(f.result(3), results[-1])
def test_executor(self):
executor = ThreadExecutor()
f = executor.submit(QThread.currentThread)
self.assertIsNot(f.result(3), QThread.currentThread())
f = executor.submit(lambda: 1 / 0)
with self.assertRaises(ZeroDivisionError):
f.result()
results = []
task = Task(function=QThread.currentThread)
task.resultReady.connect(results.append, Qt.DirectConnection)
f = executor.submit(task)
self.assertIsNot(f.result(3), QThread.currentThread())
executor.shutdown()
def test_calnet_measurements_substances(self):
def prov_finished(result):
# [{'code': 'C501', 'description': 'JUICE - FRUIT UNSPECIFIED (C501)'}, ...
# TODO some better testing here
print result
self.prov.finished.connect(prov_finished)
self.prov.get_data('Substances')
while not self.prov.is_finished():
QCoreApplication.processEvents()
class TestTask(unittest.TestCase):
def setUp(self):
self.app = QCoreApplication([])
def test_task(self):
results = []
task = Task(function=QThread.currentThread)
task.resultReady.connect(results.append)
task.start()
self.app.processEvents()
self.assertSequenceEqual(results, [QThread.currentThread()])
results = []
thread = QThread()
thread.start()
task = Task(function=QThread.currentThread)
task.moveToThread(thread)
self.assertIsNot(task.thread(), QThread.currentThread())
self.assertIs(task.thread(), thread)
task.resultReady.connect(results.append, Qt.DirectConnection)
task.start()
f = task.future()
self.assertIsNot(f.result(3), QThread.currentThread())
self.assertIs(f.result(3), results[-1])
def test_executor(self):
executor = ThreadExecutor()
f = executor.submit(QThread.currentThread)
self.assertIsNot(f.result(3), QThread.currentThread())
f = executor.submit(lambda: 1 / 0)
with self.assertRaises(ZeroDivisionError):
f.result()
results = []
task = Task(function=QThread.currentThread)
task.resultReady.connect(results.append, Qt.DirectConnection)
f = executor.submit(task)
self.assertIsNot(f.result(3), QThread.currentThread())
executor.shutdown()
def flush(self, error=False, prompt=False):
"""Flush buffer, write text to console"""
text = "".join(self.__buffer)
self.__buffer = []
self.insert_text(text, at_end=True, error=error, prompt=prompt)
QCoreApplication.processEvents()
self.repaint()
# Clear input buffer:
self.new_input_line = True
def test_network_mixin_get(self):
"""Test network mixin get"""
request_url = 'http://jsonplaceholder.typicode.com/posts/1'
manager = NetworkMixin(request_url=request_url)
manager.connect_get()
while not manager.is_finished():
QCoreApplication.processEvents()
self.assertIsNotNone(manager.get_json_results())
self.assertEqual(manager.get_json_results()['userId'],
self.api_results['userId'])
def _runGeoreference(self, closeOnDone):
self._closeOnDone = closeOnDone
gc = self._gc()
if (not gc.isValid()):
self._showStatus('ERROR: Please set all 4 Ground Control Points!')
return
self._toggleUi(False)
self._copyInputFile()
QCoreApplication.processEvents()
self._georeferencer.run(gc, self.rawFileInfo(), self.pointFileInfo(), self.geoFileInfo())
def run(self, *args, **kwargs):
self.stopping = False
self.running = True
try:
getattr(QCoreApplication, "exec_")()
except AttributeError:
getattr(QCoreApplication, "exec")()
QCoreApplication.processEvents()
self.stopping = True
self.running = False
