def _wrap_request(self, request):
req = QNetworkRequest(request)
req_id = next(self._request_ids)
req.setAttribute(self._REQUEST_ID, req_id)
if hasattr(request, 'timeout'):
req.timeout = request.timeout
return req, req_id
def query(self, query):
"""
Perform a nominatim query
@param query: Query to execute
@type query: str
@raise NetWorkErrorException
@return: the result of the query
@rtype: str
"""
url_query = QUrl(self.__url)
query = QUrl.toPercentEncoding(query)
url_query.addEncodedQueryItem('q', query)
url_query.addQueryItem('info', 'QgisQuickOSMPlugin')
request = QNetworkRequest(url_query)
request.setRawHeader("User-Agent", "QuickOSM")
self.network_reply = self.network.get(request)
self.loop = QEventLoop()
self.network.finished.connect(self._end_of_request)
self.loop.exec_()
if self.network_reply.error() == QNetworkReply.NoError:
return json.loads(self.data)
else:
raise NetWorkErrorException(suffix="Nominatim API")
def download_file(self, url, path_file):
"""
download function
:param url: url path of file
:param path_file: path to save file
:return:
"""
self.file_install = path_file
self.url = url
loop = QEventLoop()
timer = QTimer()
timer.setSingleShot(True)
timer.timeout.connect(lambda: loop.exit(1))
timer.start(100000) # 10 second time-out
# req = QNetworkRequest(QUrl('https://www.python.org/'))
req = QNetworkRequest(QUrl(url))
result = self.manager.get(req)
result.finished.connect(lambda: self.fin_req(loop, result))
self.print_('fetching request...', self.dbg)
if loop.exec_() == 0:
timer.stop()
self.print_(
'{} is received: {}'.format(os.path.basename(path_file),
result.readAll().count()),
self.dbg)
else:
self.print_('request timed-out')
def run(self):
"""
Start the download
:return: None
"""
self.manager.get(QNetworkRequest(self.file))
self.finished.emit()
def __sync_request(self, url):
_url = QUrl(url)
_request = QNetworkRequest(_url)
self.__replies.append(_request)
QgsNetworkAccessManager.instance().sslErrors.connect(
self.__supress_ssl_errors)
_reply = QgsNetworkAccessManager.instance().get(_request)
# wait
loop = QEventLoop()
_reply.finished.connect(loop.quit)
loop.exec_()
_reply.finished.disconnect(loop.quit)
QgsNetworkAccessManager.instance().sslErrors.disconnect(
self.__supress_ssl_errors)
loop = None
error = _reply.error()
if error != QNetworkReply.NoError:
raise Exception(error)
result_code = _reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)
result = _reply.readAll()
self.__replies.append(_reply)
_reply.deleteLater()
if result_code in [301, 302, 307]:
redirect_url = _reply.attribute(
QNetworkRequest.RedirectionTargetAttribute)
return self.__sync_request(redirect_url)
else:
return result
def __init__(self, iface, data, fallback=False):
QObject.__init__(self)
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.fallback = fallback
self.settings = QSettings("CatAIS", "GeoAdminSearch")
mapServer = self.settings.value(
"services/mapserver",
"https://api3.geo.admin.ch/rest/services/api/MapServer")
self.settings = QSettings("CatAIS", "GeoAdminSearch")
searchLanguage = self.settings.value("options/language", "de")
self.userName = self.settings.value("options/username", "")
self.password = self.settings.value("options/password", "")
self.layerName = data['layer']
url = mapServer + "?searchText="
url += self.layerName.strip()
url += "&lang=" + searchLanguage
# It does not work:
# a) when networkAccess is not 'self'
# b) without lambda
self.networkAccess = QNetworkAccessManager()
self.connect(
self.networkAccess,
SIGNAL("finished(QNetworkReply*)"),
lambda event, data=data: self.receiveLayerMetadata(event, data))
self.networkAccess.get(QNetworkRequest(QUrl(url)))
def request(self,
iri,
method="GET",
extra_headers=None,
oauth_credentials=None,
post_content=None):
"""Return a deferred that will be fired with a Response object."""
uri = self.iri_to_uri(iri)
request = QNetworkRequest(QUrl(uri))
request.setSslConfiguration(self.ssl_config)
headers = yield self.build_request_headers(uri, method, extra_headers,
oauth_credentials)
for key, value in headers.items():
request.setRawHeader(key, value)
post_buffer = QBuffer()
post_buffer.setData(post_content)
try:
result = yield self._perform_request(request, method, post_buffer)
except ProxyUnauthorizedError as e:
app_proxy = QNetworkProxy.applicationProxy()
proxy_host = app_proxy.hostName() if app_proxy else "proxy server"
got_creds = yield self.request_proxy_auth_credentials(
proxy_host, self.proxy_retry)
if got_creds:
self.proxy_retry = True
result = yield self.request(iri, method, extra_headers,
oauth_credentials, post_content)
else:
excp = WebClientError('Proxy creds needed.', e)
defer.returnValue(excp)
defer.returnValue(result)
def run(self):
self.setStatusMessage("Downloading")
self.info.setText(self.downloadmessage)
target_dir = os.path.join(environ.buffer_dir, "serverfiles_pack_cache")
try:
os.makedirs(target_dir)
except OSError:
pass
self.progressBarInit()
req = QNetworkRequest(QUrl(self.downloadurl))
self.reply = self.net_manager.get(req)
self.reply.downloadProgress.connect(self._progress)
self.reply.error.connect(self._error)
self.reply.finished.connect(self._finished)
self.reply.readyRead.connect(self._read)
url = urlparse.urlsplit(self.downloadurl)
self._tmpfilename = posixpath.basename(url.path)
self._tmpfile = open(
os.path.join(target_dir, self._tmpfilename), "wb+"
)
def asyncGetLatestVersion(self, uuid, use_stats):
url = self.getRequestUrl(uuid, use_stats)
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.asyncGetLatestVersionComplete)
self.nam.get(QNetworkRequest(QUrl(str(url))))
def openUrl(self, address, op, settings):
operation = op
body = QByteArray()
self.applySettings(settings)
self.m_webPage.triggerAction(QWebPage.Stop)
if type(op) is dict:
operation = op.get('operation')
body = QByteArray(op.get('data', ''))
if operation == '':
operation = 'get'
networkOp = QNetworkAccessManager.CustomOperation
operation = operation.lower()
if operation == 'get':
networkOp = QNetworkAccessManager.GetOperation
elif operation == 'head':
networkOp = QNetworkAccessManager.HeadOperation
elif operation == 'put':
networkOp = QNetworkAccessManager.PutOperation
elif operation == 'post':
networkOp = QNetworkAccessManager.PostOperation
elif operation == 'delete':
networkOp = QNetworkAccessManager.DeleteOperation
if networkOp == QNetworkAccessManager.CustomOperation:
self.m_mainFrame.evaluateJavaScript(
'console.error("Unknown network operation: %s");' % operation)
return
self.m_mainFrame.load(QNetworkRequest(QUrl(address)), networkOp, body)
def open(self, address, method='get', headers={}, auth=None):
"""Opens a web page.
:param address: The resource URL.
:param method: The Http method.
:param headers: An optional dict of extra request hearders.
:param auth: An optional tupple of HTTP auth (username, password).
:return: Page resource, All loaded resources.
"""
body = QByteArray()
try:
method = getattr(QNetworkAccessManager,
"%sOperation" % method.capitalize())
except AttributeError:
raise Exception("Invalid http method %s" % method)
request = QNetworkRequest(QUrl(address))
request.CacheLoadControl(0)
if not "User-Agent" in headers:
headers["User-Agent"] = self.user_agent
for header in headers:
request.setRawHeader(header, headers[header])
self._auth = auth
self._auth_attempt = 0 # Avoids reccursion
self.main_frame.load(request, method, body)
self.loaded = False
return self.wait_for_page_loaded()
def cbUserData(self, data):
if 'error' in data:
# TODO Create image for error
self.nameLB.setText(
"<html><head/><body><p><span style=\" text-decoration: underline; color:red;\">error</span></p></body></html>"
)
self.error.emit(data['error'])
return
self.currentUserData = data
self.settings.setValue('/CartoDBPlugin/selected', self.currentUser)
manager = QNetworkAccessManager()
manager.finished.connect(self.returnAvatar)
if 's3.amazonaws.com' in data['avatar_url']:
imageUrl = QUrl(data['avatar_url'])
else:
imageUrl = QUrl('http:' + data['avatar_url'])
request = QNetworkRequest(imageUrl)
request.setRawHeader('User-Agent', 'QGIS 2.x')
reply = manager.get(request)
loop = QEventLoop()
reply.finished.connect(loop.exit)
loop.exec_()
def __init__(self, iface, data, fallback = False):
QObject.__init__(self)
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.fallback = fallback
self.settings = QSettings("CatAIS","GeoAdminSearch")
self.wmtsCapabilitities = self.settings.value("services/wmtscapabilities", "http://api3.geo.admin.ch/rest/services/api/1.0.0/WMTSCapabilities.xml")
self.settings = QSettings("CatAIS","GeoAdminSearch")
searchLanguage = self.settings.value("options/language", "de")
self.userName = self.settings.value("options/username", "")
self.password = self.settings.value("options/password", "")
self.layerName = data['layer']
url = self.wmtsCapabilitities
# It does not work:
# a) when networkAccess is not 'self'
# b) without lambda
self.networkAccess = QNetworkAccessManager()
self.connect(self.networkAccess, SIGNAL("finished(QNetworkReply*)"), lambda event, data=data: self.receiveWmtsCapabilities(event, data))
self.networkAccess.get(QNetworkRequest(QUrl(url)))
def make_request(self, url):
url = QUrl(url)
req = QNetworkRequest(url)
for header in self.headers:
val = self.headers[header]
req.setRawHeader(header, val)
return req
def getUpdateInfo(self):
verurl = 'http://tortoisehg.bitbucket.org/curversion.txt'
# If we use QNetworkAcessManager elsewhere, it should be shared
# through the application.
self._netmanager = QNetworkAccessManager(self)
self._newverreply = self._netmanager.get(QNetworkRequest(QUrl(verurl)))
self._newverreply.finished.connect(self.uFinished)
def _make_request(self, event):
url = QUrl("{0}/notify_{1}/{2}".format(self.SERVER_URL, event,
self.equipment))
self.log.debug("Sending notification for '{0}' event to {1}".format(
event, url.toString()))
reply = self.manager.get(QNetworkRequest(url))
reply.error.connect(self._reply_error)
return reply
def _make_request(self, url):
url = QUrl.fromEncoded(url, QUrl.TolerantMode)
#url = QUrl(url, QUrl.StrictMode)
#url = QUrl.setUrl(url, QUrl.StrictMode)
request = QNetworkRequest(url)
#request = QNetworkRequest(url)
return request
def setRemotePixmap(self, url):
# Lazy creation of QNetworkManager, image download is asynchronous.
# When the image download is complete (ie the "finished" signal),
# the image data is read and drawn.
if self.connection is None:
self.connection = QNetworkAccessManager(self)
self.connection.finished.connect(self.pixmapReceived)
self.connection.get(QNetworkRequest(QUrl(url)))
def checkWeather(self):
if self.reply is not None:
return
request = QNetworkRequest()
request.setUrl(QUrl("http://api.liqwei.com/weather/"))
self.reply = self.http.get(request)
self.reply.finished.connect(self.onReplyFinished)
self.reply.error.connect(self.onReplyError)
def downloadModPreview(self, strurl, requester):
url = QtCore.QUrl(strurl)
if not url.toString() in self.modRequests:
logger.debug("Searching mod preview for: " +
os.path.basename(strurl).rsplit('.', 1)[0])
self.modRequests[url.toString()] = []
request = QNetworkRequest(url)
self.nam.get(request)
self.modRequests[url.toString()].append(requester)
def grabHTTP(self, url, loadFunction, arguments=None):
"""Grab distant content via QGIS internal classes and QtNetwork."""
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
request = QUrl(url)
reply = self.manager.get(QNetworkRequest(request))
if arguments:
reply.finished.connect(partial(loadFunction, reply, arguments))
else:
reply.finished.connect(partial(loadFunction, reply))
def get(self, mgr , url):
request = QNetworkRequest(QtCore.QUrl(url))
self.reply = mgr.get(request)
self.reply.finished.connect(self.replyfinished)
self.reply.readyRead.connect(self.readyRead)
return self.reply
def gettemp():
global tempreply
host = 'localhost'
if platform.uname()[1] == 'KW81':
host = 'piclock.local' #this is here just for testing
r = QUrl('http://' + host + ':48213/temp')
r = QNetworkRequest(r)
tempreply = manager.get(r)
tempreply.finished.connect(tempfinished)
def check_updates(self, server, installedprojects):
if not server:
return
self.server = server
req = QNetworkRequest(QUrl(self.configurl))
reply = self.net.get(req)
reply.finished.connect(
functools.partial(self.list_versions, reply, installedprojects))
def login(self):
def showError(err):
self.dlg.loginErrorLabel.setText(err)
self.dlg.loginErrorLabel.show()
self.dlg.selectThemeLabel.hide()
self.dlg.themesBox.hide()
def showSuccess():
self.dlg.loginErrorLabel.hide()
self.dlg.selectThemeLabel.show()
self.dlg.themesBox.show()
self.authCookies = None
password = None
if (self.settings.contains("password")):
password = self.settings.value("password")
email = None
if (self.settings.contains("email")):
email = self.settings.value("email")
if password == None or password == "" or email == None or email == "":
showError("login failed, no email or password.")
return False
try:
network = QgsNetworkAccessManager.instance()
url = QUrl('https://scalgo.com/py/liveLogin/login')
url.addQueryItem('usernameOrEmail', email)
url.addQueryItem('password', password)
req = QNetworkRequest(url)
reply = network.get(req)
while not reply.isFinished():
QCoreApplication.processEvents()
status_code = reply.attribute(
QNetworkRequest.HttpStatusCodeAttribute)
if status_code == 200:
showSuccess()
return True
data = reply.readAll()
if data is None:
showError("Empty login response.")
return False
resp = json.loads(unicode(data, "utf-8"))
if 'message' in resp:
showError("Login failure: %s" % resp['message'])
else:
showError("Login failure: %s" % r.status_code)
except TypeError as te:
showError("Unknown login error: %s" % te)
return False
def saveImageas(self, url):
self.messageBuffer = QByteArray()
#url = QUrl("http://upload.wikimedia.org/wikipedia/commons/f/fe/Google_Images_Logo.png")
req = QNetworkRequest(url)
self.reply = self.get(req)
QObject.connect(self.reply, SIGNAL("readyRead()"), self,
SLOT("slotReadData()"))
QObject.connect(self.reply, SIGNAL("finished()"), self,
SLOT("slotFinished()"))
def post(self, mgr , url , datas):
request = QNetworkRequest(QtCore.QUrl(url))
request.setHeader(QNetworkRequest.ContentTypeHeader,"application/x-www-form-urlencoded")
self.reply = mgr.post(request , datas)
self.reply.finished.connect(self.replyfinished)
self.reply.readyRead.connect(self.readyRead)
return self.reply
def __getReleasesFile(self, url):
"""
This method gets the releases file.
"""
LOGGER.debug("> Downloading '{0}' releases file.".format(url.path()))
self.__engine.startProcessing("Retrieving Releases File ...")
self.__releasesFileReply = self.__networkAccessManager.get(QNetworkRequest(url))
self.__releasesFileReply.finished.connect(self.__releasesFileReply__finished)
def __init__(self, url, label=None, btn=None):
QNetworkAccessManager.__init__(self)
self.messageBuffer = QByteArray()
self.label = label
self.btn = btn
self.frmt = "PNG" if url.rsplit('.', 1)[1] == 'png' else "JPG"
request = QNetworkRequest(QUrl(url))
self.reply = self.get(request)
self.reply.finished.connect(self.slotFinished)
self.reply.readyRead.connect(self.slotReadData)
def run(self):
loop = QtCore.QEventLoop()
nm = QNetworkAccessManager()
reply = nm.get(QNetworkRequest(self.url))
reply.finished.connect(loop.quit)
loop.exec_()
data = reply.readAll()
self.resourceLoaded.emit(self.res_type, self.url, data)
reply.deleteLater()
nm.deleteLater()
