eric: comparison WebBrowser/SafeBrowsing/SafeBrowsingAPIClient.py

-:5358a3c7995f
+:93c74269d59e
 str = unicode       # __IGNORE_EXCEPTION__
 except NameError:
 pass
 import json
-import random
 import base64
-from PyQt5.QtCore import pyqtSlot, pyqtSignal, QObject, QDateTime, QTimer, \
+from PyQt5.QtCore import pyqtSignal, QObject, QDateTime, QUrl, QByteArray, \
-QUrl, QByteArray
+QCoreApplication, QEventLoop
 from PyQt5.QtNetwork import QNetworkRequest, QNetworkReply
 from WebBrowser.WebBrowserWindow import WebBrowserWindow
 class SafeBrowsingAPIClient(QObject):
 """
 Class implementing the low level interface for Google Safe Browsing.
 @signal networkError(str) emitted to indicate a network error
-@signal threatLists(list) emitted to publish the received threat list
-@signal threatsUpdate(list) emitted to publish the received threats
-update
-@signal fullHashes(dict) emitted to publish the full hashes result
 """
 ClientId = "eric6_API_client"
 ClientVersion = "1.0.0"
 GsbUrlTemplate = "https://safebrowsing.googleapis.com/v4/{0}?key={1}"
 networkError = pyqtSignal(str)
-threatLists = pyqtSignal(list)
-threatsUpdate = pyqtSignal(list)
-fullHashes = pyqtSignal(dict)
 def __init__(self, apiKey, fairUse=True, parent=None):
 """
 Constructor
 self.__apiKey = apiKey
 self.__fairUse = fairUse
 self.__nextRequestNoSoonerThan = QDateTime()
 self.__failCount = 0
-# get threat lists
-self.__threatListsReply = None
-# threats lists updates
-self.__threatsUpdatesRequest = None
-self.__threatsUpdateReply = None
-# full hashes
-self.__fullHashesRequest = None
-self.__fullHashesReply = None
 def getThreatLists(self):
 """
 Public method to retrieve all available threat lists.
+@return list of threat lists
+@rtype list of dict containing 'threatType', 'platformType' and
+'threatEntryType'
 """
 url = QUrl(self.GsbUrlTemplate.format("threatLists", self.__apiKey))
 req = QNetworkRequest(url)
 reply = WebBrowserWindow.networkManager().get(req)
-reply.finished.connect(self.__threatListsReceived)
-self.__threatListsReply = reply
+while reply.isRunning():
+QCoreApplication.processEvents(QEventLoop.AllEvents, 200)
-@pyqtSlot()
+# max. 200 ms processing
-def __threatListsReceived(self):
-"""
+res = None
-Private slot handling the threat lists.
+if reply.error() != QNetworkReply.NoError:
-"""
+self.networkError.emit(reply.errorString())
-reply = self.sender()
+else:
-if reply is self.__threatListsReply:
+result = self.__extractData(reply)
-self.__threatListsReply = None
+res = result["threatLists"]
-result, hasError = self.__extractData(reply)
-if hasError:
+reply.deleteLater()
-# reschedule
+return res
-self.networkError.emit(reply.errorString())
-self.__reschedule(reply.error(), self.getThreatLists)
+def getThreatsUpdate(self, clientState):
-else:
-self.threatLists.emit(result["threatLists"])
-reply.deleteLater()
-def getThreatsUpdate(self, clientState=None):
 """
 Public method to fetch hash prefix updates for the given threat list.
 @param clientState dictionary of client states with keys like
 (threatType, platformType, threatEntryType)
 @type dict
-"""
+@return list of threat updates
-if self.__threatsUpdateReply is not None:
+@rtype list of dict
-# update is in progress
+"""
-return
+requestBody = {
+"client": {
-if clientState is None:
+"clientId": self.ClientId,
-if self.__threatsUpdatesRequest:
+"clientVersion": self.ClientVersion,
-requestBody = self.__threatsUpdatesRequest
+},
-else:
+"listUpdateRequests": [],
-return
+}
-else:
-requestBody = {
+for (threatType, platformType, threatEntryType), currentState in \
-"client": {
+clientState.items():
-"clientId": self.ClientId,
+requestBody["listUpdateRequests"].append(
-"clientVersion": self.ClientVersion,
+{
-},
+"threatType": threatType,
-"listUpdateRequests": [],
+"platformType": platformType,
-}
+"threatEntryType": threatEntryType,
+"state": currentState,
-for (threatType, platformType, threatEntryType), currentState in \
+"constraints": {
-clientState.items():
+"supportedCompressions": ["RAW"],
-requestBody["listUpdateRequests"].append(
-{
-"threatType": threatType,
-"platformType": platformType,
-"threatEntryType": threatEntryType,
-"state": currentState,
-"constraints": {
-"supportedCompressions": ["RAW"],
-}
 }
-)
+}
+)
-self.__threatsUpdatesRequest = requestBody
 data = QByteArray(json.dumps(requestBody).encode("utf-8"))
 url = QUrl(self.GsbUrlTemplate.format("threatListUpdates:fetch",
 self.__apiKey))
 req = QNetworkRequest(url)
 req.setHeader(QNetworkRequest.ContentTypeHeader, "application/json")
 reply = WebBrowserWindow.networkManager().post(req, data)
-reply.finished.connect(self.__threatsUpdateReceived)
-self.__threatsUpdateReply = reply
+while reply.isRunning():
+QCoreApplication.processEvents(QEventLoop.AllEvents, 200)
-@pyqtSlot()
+# max. 200 ms processing
-def __threatsUpdateReceived(self):
-"""
+res = None
-Private slot handling the threats update.
+if reply.error() != QNetworkReply.NoError:
-"""
+self.networkError.emit(reply.errorString())
-reply = self.sender()
+else:
-if reply is self.__threatsUpdateReply:
+result = self.__extractData(reply)
-self.__threatsUpdateReply = None
+res = result["listUpdateResponses"]
-result, hasError = self.__extractData(reply)
-if hasError:
+reply.deleteLater()
-# reschedule
+return res
-self.networkError.emit(reply.errorString())
-self.__reschedule(reply.error(), self.getThreatsUpdate)
+def getFullHashes(self, prefixes, clientState):
-else:
-self.__threatsUpdatesRequest = None
-self.threatsUpdate.emit(result["listUpdateResponses"])
-reply.deleteLater()
-def getFullHashes(self, prefixes=None, clientState=None):
 """
 Public method to find full hashes matching hash prefixes.
 @param prefixes list of hash prefixes to find
 @type list of str (Python 2) or list of bytes (Python 3)
 @param clientState dictionary of client states with keys like
 (threatType, platformType, threatEntryType)
 @type dict
-"""
+@return dictionary containing the list of found hashes and the
-if self.__fullHashesReply is not None:
+negative cache duration
-# full hash request in progress
+@rtype dict
-return
+"""
+requestBody = {
-if prefixes is None or clientState is None:
+"client": {
-if self.__fullHashesRequest:
+"clientId": self.ClientId,
-requestBody = self.__fullHashesRequest
+"clientVersion": self.ClientVersion,
-else:
+},
-return
+"clientStates": [],
-else:
+"threatInfo": {
-requestBody = {
+"threatTypes": [],
-"client": {
+"platformTypes": [],
-"clientId": self.ClientId,
+"threatEntryTypes": [],
-"clientVersion": self.ClientVersion,
+"threatEntries": [],
 },
-"clientStates": [],
+}
-"threatInfo": {
-"threatTypes": [],
+for prefix in prefixes:
-"platformTypes": [],
+requestBody["threatInfo"]["threatEntries"].append(
-"threatEntryTypes": [],
+{"hash": base64.b64encode(prefix).decode("ascii")})
-"threatEntries": [],
-},
+for (threatType, platformType, threatEntryType), currentState in \
-}
+clientState.items():
+requestBody["clientStates"].append(clientState)
-for prefix in prefixes:
+if threatType not in requestBody["threatInfo"]["threatTypes"]:
-requestBody["threatInfo"]["threatEntries"].append(
+requestBody["threatInfo"]["threatTypes"].append(threatType)
-{"hash": base64.b64encode(prefix).decode("ascii")})
+if platformType not in \
+requestBody["threatInfo"]["platformTypes"]:
-for (threatType, platformType, threatEntryType), currentState in \
+requestBody["threatInfo"]["platformTypes"].append(
-clientState.items():
+platformType)
-requestBody["clientStates"].append(clientState)
+if threatEntryType not in \
-if threatType not in requestBody["threatInfo"]["threatTypes"]:
+requestBody["threatInfo"]["threatEntryTypes"]:
-requestBody["threatInfo"]["threatTypes"].append(threatType)
+requestBody["threatInfo"]["threatEntryTypes"].append(
-if platformType not in \
+threatEntryType)
-requestBody["threatInfo"]["platformTypes"]:
-requestBody["threatInfo"]["platformTypes"].append(
-platformType)
-if threatEntryType not in \
-requestBody["threatInfo"]["threatEntryTypes"]:
-requestBody["threatInfo"]["threatEntryTypes"].append(
-threatEntryType)
-self.__fullHashesRequest = requestBody
 data = QByteArray(json.dumps(requestBody).encode("utf-8"))
 url = QUrl(self.GsbUrlTemplate.format("fullHashes:find",
 self.__apiKey))
 req = QNetworkRequest(url)
 req.setHeader(QNetworkRequest.ContentTypeHeader, "application/json")
 reply = WebBrowserWindow.networkManager().post(req, data)
-reply.finished.connect(self.__fullHashesReceived)
-self.__fullHashesReply = reply
+while reply.isRunning():
+QCoreApplication.processEvents(QEventLoop.AllEvents, 200)
-@pyqtSlot()
+# max. 200 ms processing
-def __fullHashesReceived(self):
-"""
+res = None
-Private slot handling the full hashes reply.
+if reply.error() != QNetworkReply.NoError:
-"""
+self.networkError.emit(reply.errorString())
-reply = self.sender()
+else:
-if reply is self.__fullHashesReply:
+res = self.__extractData(reply)
-self.__fullHashesReply = None
-result, hasError = self.__extractData(reply)
+reply.deleteLater()
-if hasError:
+return res
-# reschedule
-self.networkError.emit(reply.errorString())
-self.__reschedule(reply.error(), self.getFullHashes)
-else:
-self.__fullHashesRequest = None
-self.fullHashes.emit(result)
-reply.deleteLater()
 def __extractData(self, reply):
 """
 Private method to extract the data of a network reply.
 @param reply reference to the network reply object
 @type QNetworkReply
-@return tuple containing the extracted data and an error flag
+@return extracted data
-@type tuple of (list or dict, bool)
+@type list or dict
 """
-if reply.error() != QNetworkReply.NoError:
-return None, True
-self.__failCount = 0
 result = json.loads(str(reply.readAll(), "utf-8"))
 self.__setWaitDuration(result.get("minimumWaitDuration"))
-return result, False
+return result
 def __setWaitDuration(self, minimumWaitDuration):
 """
 Private method to set the minimum wait duration.
 self.__nextRequestNoSoonerThan = QDateTime()
 else:
 waitDuration = int(minimumWaitDuration.rstrip("s"))
 self.__nextRequestNoSoonerThan = \
 QDateTime.currentDateTime().addSecs(waitDuration)
-def __reschedule(self, errorCode, func):
-"""
-Private method to reschedule an API access.
-@param errorCode error code returned by the function to be rescheduled
-@type int
-@param func function to be rescheduled
-@type func
-"""
-if errorCode >= 500:
-return
-self.__failCount += 1
-waitDuration = min(
-int(2 ** (self.__failCount - 1) * 15 * 60 * (1 + random.random())),
-24 * 60 * 60)
-QTimer.singleShot(waitDuration * 1000, func)

Mercurial Repositories > eric / file comparison

comparison: WebBrowser/SafeBrowsing/SafeBrowsingAPIClient.py

WebBrowser/SafeBrowsing/SafeBrowsingAPIClient.py