def download(self, sql): apiUrl = "http://{}.cartodb.com/api/v2/sql?api_key={}&format=spatialite&q={}".format( self.cartodbUser, self.apiKey, sql ) url = QUrl(apiUrl) request = self._getRequest(url) def finished(reply): tempdir = tempfile.tempdir if tempdir is None: tempdir = tempfile.mkdtemp() tf = tempfile.NamedTemporaryFile(delete=False) sqlite = QFile(tf.name) tf.close() if sqlite.open(QIODevice.WriteOnly): sqlite.write(reply.readAll()) sqlite.close() self.fetchContent.emit(tf.name) else: self.error.emit("Error saving downloaded file") manager = QNetworkAccessManager() manager.finished.connect(finished) reply = manager.get(request) loop = QEventLoop() reply.downloadProgress.connect(self.progressCB) reply.error.connect(self._error) reply.finished.connect(loop.exit) loop.exec_()
def __init__(self, client, *args, **kwargs): BaseClass.__init__(self, *args, **kwargs) self.setupUi(self) self.client = client self.client.coopTab.layout().addWidget(self) #Dictionary containing our actual games. self.games = {} #Ranked search UI self.ispassworded = False self.loaded = False self.coop = {} self.cooptypes = {} self.canChooseMap = False self.options = [] self.client.showCoop.connect(self.coopChanged) self.client.coopInfo.connect(self.processCoopInfo) self.client.gameInfo.connect(self.processGameInfo) self.coopList.header().setResizeMode( 0, QtGui.QHeaderView.ResizeToContents) self.coopList.setItemDelegate(CoopMapItemDelegate(self)) self.gameList.setItemDelegate(GameItemDelegate(self)) self.gameList.itemDoubleClicked.connect(self.gameDoubleClicked) self.coopList.itemDoubleClicked.connect(self.coopListDoubleClicked) self.coopList.itemClicked.connect(self.coopListClicked) self.client.coopLeaderBoard.connect(self.processLeaderBoardInfos) self.tabLeaderWidget.currentChanged.connect(self.askLeaderBoard) self.linkButton.clicked.connect(self.linkVanilla) #Load game name from settings (yay, it's persistent!) self.load_last_hosted_settings() self.leaderBoard.setVisible(0) self.stylesheet = util.readstylesheet("coop/formatters/style.css") self.FORMATTER_LADDER = unicode( util.readfile("coop/formatters/ladder.qthtml")) self.FORMATTER_LADDER_HEADER = unicode( util.readfile("coop/formatters/ladder_header.qthtml")) self.leaderBoard.setStyleSheet(self.stylesheet) self.leaderBoardTextGeneral.anchorClicked.connect(self.openUrl) self.leaderBoardTextOne.anchorClicked.connect(self.openUrl) self.leaderBoardTextTwo.anchorClicked.connect(self.openUrl) self.leaderBoardTextThree.anchorClicked.connect(self.openUrl) self.leaderBoardTextFour.anchorClicked.connect(self.openUrl) self.replayDownload = QNetworkAccessManager() self.replayDownload.finished.connect(self.finishRequest) self.selectedItem = None
def createRequest(self, operation, request, outgoingData=None): try: # originatingObject = request.originatingObject() # if originatingObject: # varId = originatingObject.property('RAFT_requestId') # if varId.isValid(): # print('createRequest', '%s->%s' % (str(varId.toString()), str(request.url().toEncoded().data().decode('utf-8')))) # request.setAttribute(QtNetwork.QNetworkRequest.User + 1, varId) # requestId = str(varId.toString()) # if requestId not in self.originalRequestIds: # self.originalRequestIds.append(requestId) # request.setAttribute(QtNetwork.QNetworkRequest.User + 2, varId) url = request.url().toEncoded().data().decode('utf-8') if outgoingData is not None and type(outgoingData) == QIODevice: outgoingData = InterceptFormData(outgoingData) return StoreNetworkReply( self.framework, url, operation, request, outgoingData, self.cookieJar(), QNetworkAccessManager.createRequest(self, operation, request, outgoingData), self) except Exception as error: # exceptions will cause a segfault import traceback print(('--->FIX ME:\n%s' % traceback.format_exc(error))) request.setUrl(QUrl('about:blank')) return QNetworkAccessManager.createRequest(self, operation, request, outgoingData)
def createRequest(self, operation, request, data): url = request.url() #print url if operation == self.GetOperation: actionName = str(url.scheme()) methodName = str(url.encodedHost()) is_action = False if url.scheme() == 'file': is_action = str(url.toEncoded()).endswith(".action") if is_action is False: return QNetworkAccessManager.createRequest( self, operation, request ) if is_action: fileAction = str(url.toEncoded()).rpartition("/")[2].split(".") actionName = fileAction[0] methodName = fileAction[1] result = self.__invokeAction(actionName, methodName, url) if result is not None: return HtmlReply(url, operation, result) return QNetworkAccessManager.createRequest( self, operation, request )
def __init__(self, old_manager, book_manager, parent=None): QNetworkAccessManager.__init__(self, parent) self.parent = parent self.old_manager = old_manager self.book_manager = book_manager self.setCache(old_manager.cache())
def download(self, sql): apiUrl = 'http://{}.{}/api/v2/sql?api_key={}&format=spatialite&q={}'.format( self.cartodbUser, self.hostname, self.apiKey, sql) url = QUrl(apiUrl) request = self._getRequest(url) def finished(reply): tempdir = tempfile.tempdir if tempdir is None: tempdir = tempfile.mkdtemp() tf = tempfile.NamedTemporaryFile(delete=False) sqlite = QFile(tf.name) tf.close() if (sqlite.open(QIODevice.WriteOnly)): sqlite.write(reply.readAll()) sqlite.close() self.fetchContent.emit(tf.name) else: self.error.emit('Error saving downloaded file') manager = QNetworkAccessManager() manager.finished.connect(finished) reply = manager.get(request) loop = QEventLoop() reply.downloadProgress.connect(self.progressCB) reply.error.connect(self._error) reply.finished.connect(loop.exit) loop.exec_()
class FileCopier(QObject): """ Copies files from network """ finished = pyqtSignal() def __init__(self, file): super(FileCopier, self).__init__() self.file = QUrl("file:///{}".format(file)) self.manager = QNetworkAccessManager(self) self.connect(self.manager, SIGNAL("finished(QNetworkReply*)"), self.reply_finished) def reply_finished(self, reply): checkout_class = CheckoutStatusWindow() self.connect(reply, SIGNAL("downloadProgress(int, int)"), checkout_class.update_progress_bar) self.reply = reply checkout_class.progressBar.setMaximum(reply.size()) def run(self): """ Start the download :return: None """ self.manager.get(QNetworkRequest(self.file)) self.finished.emit()
def __init__(self, proxy, allowed_media, allowed_regex, cache_size=100, cache_dir='.webkit_cache'): """ See JQueryBrowser for details of arguments cache_size is the maximum size of the webkit cache (MB) """ QNetworkAccessManager.__init__(self) # initialize the manager cache #QDesktopServices.storageLocation(QDesktopServices.CacheLocation) cache = QNetworkDiskCache() cache.setCacheDirectory(cache_dir) cache.setMaximumCacheSize(cache_size * 1024 * 1024) # need to convert cache value to bytes self.setCache(cache) self.allowed_regex = allowed_regex # allowed content extensions self.banned_extensions = common.MEDIA_EXTENSIONS for ext in allowed_media: if ext in self.banned_extensions: self.banned_extensions.remove(ext) # and proxy self.setProxy(proxy)
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 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 __init__(self, *args, **kwargs): self.app = QApplication(sys.argv) self.option_defaults.update(kwargs) for k, v in self.option_defaults.items(): if isinstance(v, basestring): if k in ['margin_left', 'margin_right', 'margin_top', 'margin_bottom']: v = self.parseUnitReal(v) if k == 'pageSize': v = self.setPageSize(v) if k == 'orientation': v = self.setOrientation(v) if k == 'colorMode': v = self.setColorMode(v) setattr(self, k, v) if len(args) < 2: self.app.quit(1) raise Exception( 'You need to specify atleast one input file, and exactly one output file\nUse - for stdin or stdout\n\n') args = list(args) self.out = args.pop(-1) self.in_ = args self.pageNum = 0 self.pages = [] self.am = QNetworkAccessManager() self.am.connect(self.am, SIGNAL("sslErrors(QNetworkReply*, const QList<QSslError>&)"), self.sslErrors) self.loading = 0 self.quiet = True
def activate(self, engine): """ This method activates the Component. :param engine: Engine to attach the Component to. ( QObject ) :return: Method success. ( Boolean ) """ LOGGER.debug("> Activating '{0}' Component.".format(self.__class__.__name__)) self.__engine = engine self.__settings = self.__engine.settings self.__settingsSection = self.name self.__preferencesManager = self.__engine.componentsManager["factory.preferencesManager"] self.__templatesOutliner = self.__engine.componentsManager["core.templatesOutliner"] self.__locationsBrowser = self.__engine.componentsManager["addons.locationsBrowser"] self.__ioDirectory = os.path.join(self.__engine.userApplicationDataDirectory, Constants.ioDirectory, self.__ioDirectory) not foundations.common.pathExists(self.__ioDirectory) and os.makedirs(self.__ioDirectory) self.__networkAccessManager = QNetworkAccessManager() self.__reportUpdateStatus = True self.activated = True return True
def __init__(self, old_manager): QNetworkAccessManager.__init__(self) self.setCache(old_manager.cache()) self.setCookieJar(old_manager.cookieJar()) self.setProxy(old_manager.proxy()) self.setProxyFactory(old_manager.proxyFactory())
def __init__(self, parent=None): """Constructor.""" QDockWidget.__init__(self, parent) self.setupUi(self) self.SEARCH_URL = "http://www.catais.org/wsgi/search_metadb_sogis.wsgi?query=" self.toolButtonReset.setIcon(QIcon(':/plugins/sogisbrowser/icons/reset.svg')) today = QDateTime.currentDateTime() self.dateEdit.setDateTime(today) self.dateEdit.setCalendarPopup(True) self.treeWidget = SogisBrowserTreeWidget() self.gridLayout.addWidget(self.treeWidget) # self.dateEdit.setLocale(QLocale(QLocale.German)); # Qt Designer font = QFont() font.setPointSize(10) self.treeWidget.setFont(font) self.networkManager = QNetworkAccessManager(self) self.connect(self.networkManager, SIGNAL("finished(QNetworkReply*)"), self.handleNetworkData) QObject.connect(self.toolButtonReset, SIGNAL("clicked()"), self.resetSuggest)
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 createRequest(self, operation, request, outgoingData = None): try: # originatingObject = request.originatingObject() # if originatingObject: # varId = originatingObject.property('RAFT_requestId') # if varId.isValid(): # print('createRequest', '%s->%s' % (str(varId.toString()), str(request.url().toEncoded().data().decode('utf-8')))) # request.setAttribute(QtNetwork.QNetworkRequest.User + 1, varId) # requestId = str(varId.toString()) # if requestId not in self.originalRequestIds: # self.originalRequestIds.append(requestId) # request.setAttribute(QtNetwork.QNetworkRequest.User + 2, varId) url = request.url().toEncoded().data().decode('utf-8') if outgoingData is not None and type(outgoingData) == QIODevice: outgoingData = InterceptFormData(outgoingData) return StoreNetworkReply(self.framework, url, operation, request, outgoingData, self.cookieJar(), QNetworkAccessManager.createRequest(self, operation, request, outgoingData), self) except Exception as error: # exceptions will cause a segfault import traceback print(('--->FIX ME:\n%s' % traceback.format_exc(error))) request.setUrl(QUrl('about:blank')) return QNetworkAccessManager.createRequest(self, operation, request, outgoingData)
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 __init__(self, parent=None): super(MikiEdit, self).__init__(parent) self.parent = parent self.settings = parent.settings self.setFontPointSize(12) self.setVisible(False) self.ix = open_dir(self.settings.indexdir) # Spell checker support try: import enchant enchant.Dict() self.speller = enchant.Dict() except ImportError: print("Spell checking unavailable. Need to install pyenchant.") self.speller = None except enchant.errors.DictNotFoundError: print( "Spell checking unavailable. Need to install dictionary (e.g. aspell-en)." ) self.speller = None self.imageFilter = "" self.documentFilter = "" for ext in self.settings.attachmentImage: self.imageFilter += " *" + ext for ext in self.settings.attachmentDocument: self.documentFilter += " *" + ext self.imageFilter = "Image (" + self.imageFilter.strip() + ")" self.documentFilter = "Document (" + self.documentFilter.strip() + ")" self.downloadAs = "" self.networkManager = QNetworkAccessManager() self.networkManager.finished.connect(self.downloadFinished)
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, *args, **kwargs): """Initialize this instance.""" super(WebClient, self).__init__(*args, **kwargs) self.nam = QNetworkAccessManager(QCoreApplication.instance()) self.nam.finished.connect(self._handle_finished) self.nam.authenticationRequired.connect(self._handle_authentication) self.nam.proxyAuthenticationRequired.connect(self.handle_proxy_auth) self.nam.sslErrors.connect(self._handle_ssl_errors) self.replies = {} self.proxy_retry = False self.setup_proxy() # Force Qt to load the system certificates QSslSocket.setDefaultCaCertificates(QSslSocket.systemCaCertificates()) # Apply our local certificates as the SSL configuration to be used # for all QNetworkRequest calls. self.ssl_config = QSslConfiguration.defaultConfiguration() ca_certs = self.ssl_config.caCertificates() try: for path in glob.glob( os.path.join(get_cert_dir(), "UbuntuOne*.pem")): with open(path) as f: cert = QSslCertificate(f.read()) if cert.isValid(): ca_certs.append(cert) else: logger.error("invalid certificate: {}".format(path)) except (IndexError, IOError) as err: raise WebClientError( "Unable to configure SSL certificates: {}".format(err)) self.ssl_config.setCaCertificates(ca_certs)
def fetch_zip(url, output_path, feature_type, progress_dialog=None): """Download zip containing shp file and write to output_path. .. versionadded:: 3.2 :param url: URL of the zip bundle. :type url: str :param output_path: Path of output file, :type output_path: str :param feature_type: What kind of features should be downloaded. Currently 'buildings', 'building-points' or 'roads' are supported. :type feature_type: str :param progress_dialog: A progress dialog. :type progress_dialog: QProgressDialog :raises: ImportDialogError - when network error occurred """ LOGGER.debug('Downloading file from URL: %s' % url) LOGGER.debug('Downloading to: %s' % output_path) if progress_dialog: progress_dialog.show() # Infinite progress bar when the server is fetching data. # The progress bar will be updated with the file size later. progress_dialog.setMaximum(0) progress_dialog.setMinimum(0) progress_dialog.setValue(0) # Get a pretty label from feature_type, but not translatable label_feature_type = feature_type.replace('-', ' ') label_text = tr('Fetching %s' % label_feature_type) progress_dialog.setLabelText(label_text) # Set Proxy in web page proxy = get_proxy() network_manager = QNetworkAccessManager() if proxy is not None: network_manager.setProxy(proxy) # Download Process downloader = FileDownloader(network_manager, url, output_path, progress_dialog) try: result = downloader.download() except IOError as ex: raise IOError(ex) if result[0] is not True: _, error_message = result if result[0] == QNetworkReply.OperationCanceledError: raise CanceledImportDialogError(error_message) else: raise DownloadError(error_message)
def __init__(self, parent, iface, chunks, playlistUrl, mimeType, encoding): super(Streaming, self).__init__() self.DEBUG = True # Variables from other classes self.parent = parent # For GUI access self.iface = iface self.chunks = chunks self.playlistUrl = playlistUrl self.mimeType = mimeType self.encoding = encoding # Internal variables self.__endTag = "#PLAYLIST-END" self.__exceptionTag = "#EXCEPTION" self.__exceptionUrl = "" self.__exceptionFound = False self.__playlistFinished = False # Did the end tag appeared? self.__bytesInlastReply = 0 # To compare last and current reply sizes self.__loadedChunks = 0 # For keeping track of # of loaded (to local vars) chunks self.__deliveredChunks = 0 # For keeping track of # of loaded (to the map) chunks self.__bFirstChunk = True self.__features = {} # {0:[f0,f1,f2], 1:[f0,f1]} self.__bGeomMulti = False # Is the geometry multi{point|line|polygon} self.__geometryType = "" # Values: "Point","LineString","Polygon","Unknown", "NoGeometry" self.__tmpGeometry = {} # For visualization purposes {chunkId1: rb1, chunkId2: rb2 } self.__memoryLayer = None # The whole merged data # For rasters only self.__legend = self.iface.legendInterface() self.__groupIndex = 0 self.__chunksDir = None self.__virtualFile = "" # Virtual raster file path if isMimeTypeRaster(self.mimeType, True) != None: self.__chunksDir = tempfile.mkdtemp(prefix="tmpChunks") # Other objects self.timer = QTimer() self.timer.setInterval(1 * 1000) # 1 second self.QNAM4Playlist = QNetworkAccessManager() self.QNAM4Chunks = QNetworkAccessManager() self.QNAM4Exception = QNetworkAccessManager() # SIGNAL/SLOT connections self.playlistHandled.connect(self.fetchChunks) self.urlReady.connect(self.fetchResult) self.dataReady.connect(self.loadData) self.timer.timeout.connect(partial(self.fetchPlaylist, self.playlistUrl)) self.QNAM4Playlist.finished.connect(self.handlePlaylist) self.QNAM4Chunks.finished.connect(self.handleChunk) self.QNAM4Exception.finished.connect(self.handleException) #self.QNAM4Playlist = QgsNetworkAccessManager.instance() #theReply2.error.connect(self.handleErrors) # GUI self.parent.progressBar.setRange(0,0) self.parent.lblProcess.setText("Reading output playlist...")
def fetch_zip(url, output_path, feature_type, progress_dialog=None): """Download zip containing shp file and write to output_path. .. versionadded:: 3.2 :param url: URL of the zip bundle. :type url: str :param output_path: Path of output file, :type output_path: str :param feature_type: What kind of features should be downloaded. Currently 'buildings', 'building-points' or 'roads' are supported. :type feature_type: str :param progress_dialog: A progress dialog. :type progress_dialog: QProgressDialog :raises: ImportDialogError - when network error occurred """ LOGGER.debug('Downloading file from URL: %s' % url) LOGGER.debug('Downloading to: %s' % output_path) if progress_dialog: progress_dialog.show() # Infinite progress bar when the server is fetching data. # The progress bar will be updated with the file size later. progress_dialog.setMaximum(0) progress_dialog.setMinimum(0) progress_dialog.setValue(0) # Get a pretty label from feature_type, but not translatable label_feature_type = feature_type.replace('-', ' ') label_text = tr('Fetching %s' % label_feature_type) progress_dialog.setLabelText(label_text) # Set Proxy in web page proxy = get_proxy() network_manager = QNetworkAccessManager() if proxy is not None: network_manager.setProxy(proxy) # Download Process downloader = FileDownloader( network_manager, url, output_path, progress_dialog) try: result = downloader.download() except IOError as ex: raise IOError(ex) if result[0] is not True: _, error_message = result if result[0] == QNetworkReply.OperationCanceledError: raise CanceledImportDialogError(error_message) else: raise DownloadError(error_message)
def createRequest(self, op, request, device=None): global lst, pg try: #print(str(request.url())) urlLnk = (request.url()).toString() #print(urlLnk) path = str(request.url().path()) except UnicodeEncodeError: pass #print(path) lower_case = path.lower() #lst = tuple(open("easylist.txt", 'r')) lst = [ "doubleclick.net", "ads", '.jpg', '.png', '.gif', '.css', 'facebook', '.aspx', r"||youtube-nocookie.com/gen_204?", r"youtube.com###watch-branded-actions", "imagemapurl", "b.scorecardresearch.com", "rightstuff.com", "scarywater.net", "popup.js", "banner.htm", "_tribalfusion", "||n4403ad.doubleclick.net^$third-party", ".googlesyndication.com", "graphics.js", "fonts.googleapis.com/css", "s0.2mdn.net", "server.cpmstar.com", "||banzai/banner.$subdocument", "@@||anime-source.com^$document", "/pagead2.", "frugal.gif", "jriver_banner.png", "show_ads.js", '##a[href^="http://billing.frugalusenet.com/"]', "http://jriver.com/video.html", "||animenewsnetwork.com^*.aframe?", "||contextweb.com^$third-party", ".gutter", ".iab", 'http://www.animenewsnetwork.com/assets/[^"]*.jpg' ] block = False for l in lst: if lower_case.find(l) != -1: block = True break if block: #print ("Skipping") #print (request.url().path()) return QNetworkAccessManager.createRequest( self, QNetworkAccessManager.GetOperation, QtNetwork.QNetworkRequest(QtCore.QUrl())) else: if 'itag=' in urlLnk and 'redirector' not in urlLnk: print('*********') #print() #print(path) #print(urlLnk) #pg.web.setHtml('<html>got the link</html>') #self.lnkUrl.emit(path) f = open('/tmp/AnimeWatch/lnk.txt', 'w') f.write(urlLnk) f.close() return QNetworkAccessManager.createRequest( self, op, request, device) #return QNetworkAccessManager.createRequest(self, op, request, device) #return QNetworkAccessManager.createRequest(self, QNetworkAccessManager.GetOperation, QtNetwork.QNetworkRequest(QtCore.QUrl())) else: return QNetworkAccessManager.createRequest( self, op, request, device)
def __init__(self, diskCacheEnabled, parent = None): QNetworkAccessManager.__init__(self, parent) self.finished.connect(self.handleFinished) if diskCacheEnabled == 'yes': m_networkDiskCache = QNetworkDiskCache() m_networkDiskCache.setCacheDirectory(QDesktopServices.storageLocation(QDesktopServices.CacheLocation)) self.setCache(m_networkDiskCache)
def __init__(self, parent = None): """ Constructor @param parent reference to the parent object (QObject) """ QNetworkAccessManager.__init__(self, parent) self.__webPage = None
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 __init__(self, diskCacheEnabled, parent = None): QNetworkAccessManager.__init__(self, parent) self.connect(self, SIGNAL('finished(QNetworkReply *)'), self.handleFinished) if diskCacheEnabled == 'yes': m_networkDiskCache = QNetworkDiskCache() m_networkDiskCache.setCacheDirectory(QDesktopServices.storageLocation(QDesktopServices.CacheLocation)) self.setCache(m_networkDiskCache)
def __init__(self, client, *args, **kwargs): logger.debug("Lobby instantiating.") BaseClass.__init__(self, *args, **kwargs) self.setupUi(self) self.client = client #self.client.galacticwarTab.setStyleSheet(util.readstylesheet("galacticwar/galacticwar.css")) self.COLOR_FACTIONS = {} self.mapTransparency = 10 self.AA = True self.rotation = True self.stars = 25 self.GWOptions = GWOptions(self) self.GWOptions.loadSettings() self.client.galacticwarTab.layout().addWidget(self) self.downloader = QNetworkAccessManager(self) self.downloader.finished.connect(self.finishRequest) self.shaderlist = [] self.texturelist = {} self.shaders = {} self.infoPanel = None self.OGLdisplay = None self.galaxy = Galaxy(self) self.channel = None self.initDone = False self.uid = None self.faction = None self.name = None self.rank = None self.credits = 0 self.victories = 0 self.enslavedBy = None self.attacks = {} self.state = ClientState.NONE ## Network initialization self.socket = QtNetwork.QTcpSocket() self.socket.readyRead.connect(self.readFromServer) self.socket.disconnected.connect(self.disconnectedFromServer) self.socket.error.connect(self.socketError) self.blockSize = 0 self.progress = QtGui.QProgressDialog() self.progress.setMinimum(0) self.progress.setMaximum(0)
def __init__(self, parent=None, iface=None): """Constructor for import dialog. :param parent: Optional widget to use as parent :type parent: QWidget :param iface: An instance of QGisInterface :type iface: QGisInterface """ QDialog.__init__(self, parent) self.parent = parent self.setupUi(self) self.setWindowTitle(self.tr('InaSAFE OpenStreetMap Downloader')) self.iface = iface self.buildings_url = 'http://osm.linfiniti.com/buildings-shp' self.building_points_url = \ 'http://osm.linfiniti.com/building-points-shp' self.roads_url = 'http://osm.linfiniti.com/roads-shp' self.help_context = 'openstreetmap_downloader' # creating progress dialog for download self.progress_dialog = QProgressDialog(self) self.progress_dialog.setAutoClose(False) title = self.tr('InaSAFE OpenStreetMap Downloader') self.progress_dialog.setWindowTitle(title) # Set up context help help_button = self.button_box.button(QtGui.QDialogButtonBox.Help) help_button.clicked.connect(self.show_help) self.show_info() # set up the validator for the file name prefix expression = QRegExp('^[A-Za-z0-9-_]*$') validator = QRegExpValidator(expression, self.filename_prefix) self.filename_prefix.setValidator(validator) # Set Proxy in webpage proxy = get_proxy() self.network_manager = QNetworkAccessManager(self) if proxy is not None: self.network_manager.setProxy(proxy) self.restore_state() # Setup the rectangle map tool self.canvas = iface.mapCanvas() self.rectangle_map_tool = \ RectangleMapTool(self.canvas) self.rectangle_map_tool.rectangle_created.connect( self.update_extent_from_rectangle) self.button_extent_rectangle.clicked.connect( self.drag_rectangle_on_map_canvas) # Setup pan tool self.pan_tool = QgsMapToolPan(self.canvas) self.canvas.setMapTool(self.pan_tool) self.update_extent_from_map_canvas()
def __init__(self, parent=None): self.client = parent self.nam = QNetworkAccessManager() self.nam.finished.connect(self.finishedDownload) self.modRequests = {} self.mapRequests = {} self.mapRequestsItem = []
class VersionChecker(QObject): def getRequestUrl(self, uuid, use_stats): base_url = "http://comictagger1.appspot.com/latest" args = "" if use_stats: if platform.system() == "Windows": plat = "win" elif platform.system() == "Linux": plat = "lin" elif platform.system() == "Darwin": plat = "mac" else: plat = "other" args = "?uuid={0}&platform={1}&version={2}".format( uuid, plat, ctversion.version) if not getattr(sys, 'frozen', None): args += "&src=T" return base_url + args def getLatestVersion(self, uuid, use_stats=True): try: resp = urllib2.urlopen(self.getRequestUrl(uuid, use_stats)) new_version = resp.read() except Exception as e: return None if new_version is None or new_version == "": return None return new_version.strip() versionRequestComplete = pyqtSignal(str) 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 asyncGetLatestVersionComplete(self, reply): if (reply.error() != QNetworkReply.NoError): return # read in the response new_version = str(reply.readAll()) if new_version is None or new_version == "": return self.versionRequestComplete.emit(new_version.strip())
def __init__(self, old_manager, tentia_callback): QNetworkAccessManager.__init__(self) self.tentia_callback = tentia_callback self.old_manager = old_manager self.setCache(old_manager.cache()) self.setCookieJar(old_manager.cookieJar()) self.setProxy(old_manager.proxy()) self.setProxyFactory(old_manager.proxyFactory())
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 __init__(self): QWebPage.__init__(self) self.networkAccessManager = QNetworkAccessManager() self.networkNoProxy = QNetworkProxy(QNetworkProxy.NoProxy) self.networkProxy = QNetworkProxy(QNetworkProxy.HttpProxy, "127.0.0.1", 8087) self.setNetworkAccessManager(self.networkAccessManager) self.loadFinished.connect(self._loadFinished)
def createRequest(self, op, request, device=None): url = request.url().toString() doFilter = adblockFilter.match(url) if doFilter: try: return QNetworkAccessManager.createRequest(self, self.GetOperation, QtNetwork.QNetworkRequest(QtCore.QUrl())) except: print("failed to create request ...") return QNetworkAccessManager.createRequest(self, op, request, device)
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()
def __init__(self, old_manager, bungloo_callback): QNetworkAccessManager.__init__(self) self.bungloo_callback = bungloo_callback self.old_manager = old_manager self.setCache(old_manager.cache()) self.setCookieJar(old_manager.cookieJar()) self.setProxy(old_manager.proxy()) self.setProxyFactory(old_manager.proxyFactory())
def __init__(self, parent=None, signalManager=None, title="Databases Pack"): super(OWDatabasesPack, self).__init__( parent, signalManager, title, wantMainArea=False) self.fileslist = [("Taxonomy", "ncbi_taxonomy.tar.gz")] self.downloadurl = "https://dl.dropboxusercontent.com/u/100248799/sf_pack.tar.gz" self.downloadmessage = ( "Downloading a subset of available databases for a smoother " + "ride through the workshop" ) self.loadSettings() self._tmpfile = None self.reply = None # Locks held on server files self.locks = [] self.net_manager = QNetworkAccessManager() # Lock all files in files list so any other (in process) atempt to # download the files waits) box = OWGUI.widgetBox(self.controlArea, "Info") self.info = OWGUI.widgetLabel(box, self.downloadmessage) self.info.setWordWrap(True) box = OWGUI.widgetBox(self.controlArea, "Status") self.statusinfo = OWGUI.widgetLabel(box, "Please wait") self.statusinfo.setWordWrap(True) self.progressbar = QProgressBar() box.layout().addWidget(self.progressbar) self.setMinimumWidth(250) already_available = [(domain, filename) for domain in serverfiles.listdomains() for filename in serverfiles.listfiles(domain)] if set(self.fileslist) <= set(already_available): # All files are already downloaded self.statusinfo.setText("All files already available") self.setStatusMessage("Done") else: for domain, filename in self.fileslist + [("_tmp_cache_", "pack")]: manager = serverfiles._lock_file(domain, filename) try: manager.__enter__() except Exception: warnings.warn("Could not acquire lock for {0} {0}" .format(domain, filename)) self.warning(0, "...") else: self.locks.append(manager) QTimer.singleShot(0, self.show) QTimer.singleShot(0, self.run)
def __init__(self, client): super(BaseClass, self).__init__() self.setupUi(self) #self.replayVault.setVisible(False) self.client = client client.replaysTab.layout().addWidget(self) client.gameInfo.connect(self.processGameInfo) client.replayVault.connect(self.replayVault) self.onlineReplays = {} self.onlineTree.setItemDelegate(ReplayItemDelegate(self)) self.replayDownload = QNetworkAccessManager() self.replayDownload.finished.connect(self.finishRequest) # sending request to replay vault self.searchButton.pressed.connect(self.searchVault) self.playerName.returnPressed.connect(self.searchVault) self.mapName.returnPressed.connect(self.searchVault) self.myTree.itemDoubleClicked.connect(self.myTreeDoubleClicked) self.myTree.itemPressed.connect(self.myTreePressed) self.myTree.header().setResizeMode(0, QtGui.QHeaderView.ResizeToContents) self.myTree.header().setResizeMode(1, QtGui.QHeaderView.ResizeToContents) self.myTree.header().setResizeMode(2, QtGui.QHeaderView.Stretch) self.myTree.header().setResizeMode(3, QtGui.QHeaderView.ResizeToContents) self.liveTree.itemDoubleClicked.connect(self.liveTreeDoubleClicked) self.liveTree.itemPressed.connect(self.liveTreePressed) self.liveTree.header().setResizeMode( 0, QtGui.QHeaderView.ResizeToContents) self.liveTree.header().setResizeMode(1, QtGui.QHeaderView.Stretch) self.liveTree.header().setResizeMode( 2, QtGui.QHeaderView.ResizeToContents) self.games = {} self.onlineTree.itemDoubleClicked.connect(self.onlineTreeDoubleClicked) self.onlineTree.itemPressed.connect(self.onlineTreeClicked) # replay vault connection to server self.searching = False self.blockSize = 0 self.replayVaultSocket = QtNetwork.QTcpSocket() self.replayVaultSocket.error.connect(self.handleServerError) self.replayVaultSocket.readyRead.connect(self.readDataFromServer) self.replayVaultSocket.disconnected.connect(self.disconnected) self.replayVaultSocket.error.connect(self.errored) logger.info("Replays Widget instantiated.")
def __init__(self, old_manager, bungloo_callback): QNetworkAccessManager.__init__(self) self.bungloo_callback = bungloo_callback self.old_manager = old_manager self.setCache(old_manager.cache()) self.setCookieJar(old_manager.cookieJar()) self.setProxy(old_manager.proxy()) self.setProxyFactory(old_manager.proxyFactory()) self.sslErrors.connect(lambda reply, errors: old_manager.sslErrors)
def __init__(self, diskCacheEnabled, ignoreSslErrors, parent=None): QNetworkAccessManager.__init__(self, parent) self.m_ignoreSslErrors = ignoreSslErrors if parent.m_verbose: self.finished.connect(self.handleFinished) if diskCacheEnabled == 'yes': m_networkDiskCache = QNetworkDiskCache() m_networkDiskCache.setCacheDirectory(QDesktopServices.storageLocation(QDesktopServices.CacheLocation)) self.setCache(m_networkDiskCache) do_action('NetworkAccessManagerInit', Bunch(locals()))
class URLLabel(QLabel): """ QLabel subclass to support the display of images via URL. """ def __init__(self, parent): super(URLLabel, self).__init__(parent) self.connection = None self._original_pixmap = None self.connection = None def clear(self): self._original_pixmap = None super(URLLabel, self).clear() 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 pixmapReceived(self, reply): """ Slot for handling the return of the asynchronous image download. """ if reply.error() != QNetworkReply.NoError: reply.deleteLater() return data = reply.readAll() pixmap = QPixmap() pixmap.loadFromData(data) # The original image is stored as an attribute and drawn manually # using an overridden paintEvent. This is preferable to using the # setPixmap() functionality of QLabels because it allows more control # over the scaling of the pixmap and allows the size of the QLabel # to dictate the pixmap size, and not the other way around. self._original_pixmap = pixmap reply.deleteLater() self.update() def paintEvent(self, paintevent): super(URLLabel, self).paintEvent(paintevent) # Manually draw the downloaded pixmap, scaled to fit the size of the label. if self._original_pixmap: size = self.size() sized_pixmap = self._original_pixmap.scaled(size, Qt.KeepAspectRatio, Qt.SmoothTransformation) painter = QPainter(self) point = self.geometry().topLeft() painter.drawPixmap(point, sized_pixmap)
def createRequest(self, op, request, device = None ): path = str(request.url().path()) lower_case = path.lower() lst = ["banner", "ads", r"||youtube-nocookie.com/gen_204?", r"youtube.com###watch-branded-actions", "imagemapurl"] block = False for l in lst: if lower_case.find(l) != -1: block = True break if block: print "Skipping "+request.url().path() return QNetworkAccessManager.createRequest(self, QNetworkAccessManager.GetOperation, QtNetwork.QNetworkRequest(QtCore.QUrl())) else: return QNetworkAccessManager.createRequest(self, op, request, device)
def setProxy(self, proxy): """Allow setting string as proxy """ fragments = common.parse_proxy(proxy) if fragments.host: QNetworkAccessManager.setProxy(self, QNetworkProxy(QNetworkProxy.HttpProxy, fragments.host, int(fragments.port), fragments.username, fragments.password ) ) else: common.logger.info('Invalid proxy:' + proxy) proxy = None
class SettingsProtocol(QObject): readSignal = pyqtSignal(bool, int, QString) def __init__(self, host, user, password): QObject.__init__(self) # Set the host self.host = host # Create a base64 encoded credential string from user name and password. # This is required for the HTTP basic access authentication, compare # also http://en.wikipedia.org/wiki/Basic_access_authentication self.userlogin = "******" % (user, password) self.login = "******" + QByteArray(self.userlogin).toBase64() # Create a new QNetworkAccessManager and connect it to the # authenticationRequired signal self.manager = QNetworkAccessManager(self) # self.connect(self.manager, SIGNAL("authenticationRequired( QNetworkReply*, QAuthenticator* )"), self.slotAuthenticationRequired) def read(self): self.connect(self.manager, SIGNAL("finished( QNetworkReply* )"), self.readRequestFinished) url = "%s/config/geometrytaggroups" % self.host qUrl = QUrl(url) self.request = QNetworkRequest(qUrl) self.request.setRawHeader("Authorization", self.login) self.request.setHeader(QNetworkRequest.ContentTypeHeader, "application/json") self.manager.get(self.request) return url def readRequestFinished(self, reply): # Get the HTTP status code from the reply self.httpStatusCode = int(reply.attribute(QNetworkRequest.HttpStatusCodeAttribute).toString()) data = reply.readAll() # Check the status code see also http://en.wikipedia.org/wiki/HTTP_status_code # In case of a successful upload we get a 201 status code back and the # "stylePosted" signal is emitted with the first parameter set to True. # If the query didn't succeed, the status code is 4xx indicating that # the host was not found, the authentication failed or a forbidden # action in case a style with the same name already exists. It's up to # the receiver to handle these status codes. self.readSignal.emit(self.httpStatusCode in (200, 201), self.httpStatusCode, QString(data))
def __init__(self, engine, parent=None): """ Constructor @param engine reference to the help engine (QHelpEngine) @param parent reference to the parent object (QObject) """ QNetworkAccessManager.__init__(self, parent) self.__adblockNetwork = None self.__schemeHandlers = {} # dictionary of scheme handlers self.__proxyFactory = E4NetworkProxyFactory() self.setProxyFactory(self.__proxyFactory) self.__setDiskCache() self.languagesChanged() if SSL_AVAILABLE: sslCfg = QSslConfiguration.defaultConfiguration() caList = sslCfg.caCertificates() caNew = QSslCertificate.fromData(Preferences.Prefs.settings.value("Help/CaCertificates").toByteArray()) for cert in caNew: caList.append(cert) sslCfg.setCaCertificates(caList) sslCfg.setProtocol(QSsl.AnyProtocol) try: sslCfg.setSslOption(QSsl.SslOptionDisableCompression, True) except AttributeError: pass QSslConfiguration.setDefaultConfiguration(sslCfg) self.connect(self, SIGNAL("sslErrors(QNetworkReply *, const QList<QSslError> &)"), self.__sslErrors) self.connect( self, SIGNAL("proxyAuthenticationRequired(const QNetworkProxy&, QAuthenticator*)"), self.__proxyAuthenticationRequired, ) self.connect( self, SIGNAL("authenticationRequired(QNetworkReply *, QAuthenticator *)"), self.__authenticationRequired ) # register scheme handlers self.setSchemeHandler("qthelp", QtHelpAccessHandler(engine, self)) self.setSchemeHandler("pyrc", PyrcAccessHandler(self)) self.setSchemeHandler("about", AboutAccessHandler(self)) self.setSchemeHandler("abp", AdBlockAccessHandler(self))
def download_from_url(url, output_directory, filename=None, use_cache=True): """Download file from a url and put it under output_directory. :param url: Url that gives response. :type url: str :param output_directory: Directory to put the diagram. :type output_directory: str :param filename: Optional filename for downloaded file. :type filename: str :param use_cache: If there is a cached copy of the file already in the output directory, do not refetch it (True) or force refecth it (False). :type use_cache: bool :returns: File path if success to download, else None :rtype: str """ if filename is None: filename = get_filename(url) LOGGER.info('Download file %s from %s' % (filename, url)) file_path = os.path.join(output_directory, filename) if os.path.exists(file_path) and use_cache: LOGGER.info('File %s exists, not downloading' % file_path) return file_path # Set Proxy in webpage proxy = get_proxy() network_manager = QNetworkAccessManager() if not proxy is None: network_manager.setProxy(proxy) # Download Process # noinspection PyTypeChecker downloader = FileDownloader(network_manager, url, file_path) try: result = downloader.download() except IOError as ex: raise DownloadException(ex) if result[0] is not True: _, error_message = result raise DownloadException(error_message) if os.path.exists(file_path): return file_path else: return None
def createRequest(self, operation, request, outgoingData = None): reply = None try: requestUrl = request.url() scheme = str(requestUrl.scheme()) if scheme in ('data', 'about', 'javascript'): reply = QNetworkAccessManager.createRequest(self, operation, request, outgoingData) elif scheme in ('http', 'https'): url = requestUrl.toEncoded().data().decode('utf-8') url_response = None if url in self.request_lookaside: url_response = self.request_lookaside[url] else: responses = [] for row in self.Data.read_responses_by_url(self.cursor, url): responseItems = interface.data_row_to_response_items(row) response_length = str(responseItems[ResponsesTable.RES_LENGTH]) if response_length and int(response_length) > 0 and str(responseItems[ResponsesTable.STATUS]).startswith('2'): responses.append(responseItems) if len(responses) > 0: url_response = responses[-1] # TODO: implement max size limit self.request_lookaside[url] = url_response if not url_response: # try again, with base url if '?' in url: base_url = url[0:url.index('?')] else: base_url = url for row in self.Data.read_responses_starting_with_url(self.cursor, base_url): responseItems = interface.data_row_to_response_items(row) response_length = str(responseItems[ResponsesTable.RES_LENGTH]) if response_length and int(response_length) > 0 and str(responseItems[ResponsesTable.STATUS]).startswith('2'): responses.append(responseItems) if len(responses) > 0: url_response = responses[-1] self.request_lookaside[url] = url_response if url_response: reply = CustomNetworkReply(self, requestUrl, url_response[ResponsesTable.RES_HEADERS], url_response[ResponsesTable.RES_DATA]) except Exception as error: self.framework.report_implementation_error(error) if not reply: # must always return reply request.setUrl(QUrl('about:blank')) reply = QNetworkAccessManager.createRequest(self, operation, request, outgoingData) return reply
def __init__(self, parent=None): QObject.__init__(self, parent=None) assert QThread.currentThread() is QApplication.instance().thread() netmanager = self._NETMANAGER_REF and self._NETMANAGER_REF() if netmanager is None: netmanager = QNetworkAccessManager() cache = QNetworkDiskCache() cache.setCacheDirectory( os.path.join(settings.widget_settings_dir(), __name__ + ".ImageLoader.Cache") ) netmanager.setCache(cache) ImageLoader._NETMANAGER_REF = weakref.ref(netmanager) self._netmanager = netmanager
def __init__(self, parent=None): super(MikiEdit, self).__init__(parent) self.parent = parent self.settings = parent.settings self.setFontPointSize(12) self.setVisible(False) self.ix = open_dir(self.settings.indexdir) # Spell checker support try: import enchant enchant.Dict() self.speller = enchant.Dict() except ImportError: print("Spell checking unavailable. Need to install pyenchant.") self.speller = None except enchant.errors.DictNotFoundError: print("Spell checking unavailable. Need to install dictionary (e.g. aspell-en).") self.speller = None self.imageFilter = "" self.documentFilter = "" for ext in self.settings.attachmentImage: self.imageFilter += " *" + ext for ext in self.settings.attachmentDocument: self.documentFilter += " *" + ext self.imageFilter = "Image (" + self.imageFilter.strip() + ")" self.documentFilter = "Document (" + self.documentFilter.strip() + ")" self.downloadAs = "" self.networkManager = QNetworkAccessManager() self.networkManager.finished.connect(self.downloadFinished)
def createRequest(self, operation, request, data): try: requestFunc = self._dispatcher[request.url().scheme()] except KeyError: self.addHeadersToRequest(request) return QNetworkAccessManager.createRequest(self, operation, request, data) return requestFunc(self, operation, request, data)
def __init__(self, parent=None): super(ImageWidget, self).__init__(parent) self.nam = QNetworkAccessManager() self.nam.finished.connect(self.http_image_complete) self.src = '' self.max_x = None self.max_y = None
def createRequest(self, op, req, outgoingData): if op == QNetworkAccessManager.GetOperation: qDebug('HTTP/1.1 GET Request') elif op == QNetworkAccessManager.PostOperation: qDebug('HTTP/1.1 POST Request') elif op == QNetworkAccessManager.HeadOperation: qDebug('HTTP/1.1 HEAD Request') elif op == QNetworkAccessManager.PutOperation: qDebug('HTTP/1.1 PUT Request') elif op == QNetworkAccessManager.DeleteOperation: qDebug('HTTP/1.1 DELETE Request') elif op == QNetworkAccessManager.CustomOperation: qDebug('HTTP/1.1 CUSTOM Request') else: qWarning('Unexpected HTTP Operation Type') qDebug('URL %s' % req.url().toString()) do_action('NetworkAccessManagerCreateRequestPre', Bunch(locals())) reply = QNetworkAccessManager.createRequest(self, op, req, outgoingData) if self.m_ignoreSslErrors == 'yes': reply.ignoreSslErrors() do_action('NetworkAccessManagerCreateRequestPost', Bunch(locals())) return reply
def createRequest(self, op, req, outgoingData): do_action('NetworkAccessManagerCreateRequestPre') reply = QNetworkAccessManager.createRequest(self, op, req, outgoingData) if self.m_ignoreSslErrors: reply.ignoreSslErrors() headers = [] for header in req.rawHeaderList(): header = { 'name': str(header), 'value': str(req.rawHeader(header)) } headers.append(header) self.m_idCounter += 1 self.m_ids[reply] = self.m_idCounter data = { 'id': self.m_idCounter, 'url': req.url().toString(), 'method': self.operationToString(op), 'headers': headers, 'time': QDateTime.currentDateTime() } reply.readyRead.connect(self.handleStarted) do_action('NetworkAccessManagerCreateRequestPost') self.resourceRequested.emit(data) return reply
def activate(self, engine): """ Activates the Component. :param engine: Engine to attach the Component to. :type engine: QObject :return: Method success. :rtype: bool """ LOGGER.debug("> Activating '{0}' Component.".format(self.__class__.__name__)) self.__engine = engine self.__settings = self.__engine.settings self.__settingsSection = self.name self.__preferencesManager = self.__engine.componentsManager["factory.preferencesManager"] self.__templatesOutliner = self.__engine.componentsManager["core.templatesOutliner"] self.__locationsBrowser = self.__engine.componentsManager["addons.locationsBrowser"] self.__ioDirectory = os.path.join(self.__engine.userApplicationDataDirectory, Constants.ioDirectory, self.__ioDirectory) not foundations.common.pathExists(self.__ioDirectory) and os.makedirs(self.__ioDirectory) self.__networkAccessManager = QNetworkAccessManager() self.__reportUpdateStatus = True self.activated = True return True