class Browser: def __init__(self): self.network_manager = QNetworkAccessManager() self.network_manager.createRequest = self._create_request self.web_page = QWebPage() self.web_page.setNetworkAccessManager(self.network_manager) self.web_view = QWebView() self.web_view.setPage(self.web_page) self.html_data = None self.resultList = [] self.finished = threading.Event() def _create_request(self, operation, request, data): reply = QNetworkAccessManager.createRequest(self.network_manager, operation, request, data) self.resultList.append(request.url().toString()) return reply def myLoadFinish(self): #print "finished" self.finished.set() def getResourceUrlList(self, url): self.web_view.load(url) self.web_view.loadFinished.connect(self.myLoadFinish) self.finished.wait() return self.resultList
class Browser(object): def __init__(self): self.network_manager = QNetworkAccessManager() self.network_manager.createRequest = self._create_request self.network_manager.finished.connect(self._request_finished) self.web_page = QWebPage() self.web_page.setNetworkAccessManager(self.network_manager) self.web_view = QWebView() self.web_view.setPage(self.web_page) def _create_request(self, operation, request, data): print(data.readAll()) reply = QNetworkAccessManager.createRequest(self.network_manager, operation, request, data) return reply def _request_finished(self, reply): if not reply.error() == QNetworkReply.NoError: # request probably failed print(reply.error()) print(reply.errorString()) def _make_request(self, url): request = QNetworkRequest() request.setUrl(QUrl(url)) return request def _urlencode_post_data(self, post_data): post_params = QUrl() for (key, value) in post_data.items(): post_params.addQueryItem(key, unicode(value)) return post_params.encodedQuery() def perform(self, url, method='GET', post_data=dict()): request = self._make_request(url) if method == 'GET': self.web_view.load(request) else: encoded_data = self._urlencode_post_data(post_data) request.setRawHeader( 'Content-Type', QByteArray('application/x-www-form-urlencoded')) self.web_view.load(request, QNetworkAccessManager.PostOperation, encoded_data)
class Browser: def __init__(self, app): self.network_manager = QNetworkAccessManager() self.network_manager.createRequest = self._create_request self.web_page = QWebPage() self.web_page.setNetworkAccessManager(self.network_manager) self.web_view = QWebView() self.web_view.setPage(self.web_page) self.html_data = None self.app = app self.finished = threading.Event() self.resultList = [] def _create_request(self, operation, request, data): reply = QNetworkAccessManager.createRequest(self.network_manager, operation, request, data) self.resultList.append(request.url().toString()) return reply def myLoadFinish(self): app.quit()
def testSetNetworkAccessManager(self): page = QWebPage() manager = QNetworkAccessManager() page.setNetworkAccessManager(manager)
class Jaime(QObject,Singleton): instance = None logger = None def __init__(self): if Jaime.instance: raise Exception("Can't call to constructor with another instance created") self.tabs_widget = QTabWidget() self.view = QWebView() self.page = QWebPage() self.config = SafeConfigParser() Logger.getLoggerFor(self.__class__) self.tabs_widget.insertTab(0,self.view,'label') self.tabs = {} self.graph_file = None self.close_tab_timer = QTimer() self.close_tab_timer.setSingleShot(False) #cada 30 segundos se cierra un tab self.close_tab_timer.setInterval(10000) self.view.setPage(self.page) self.tabs['mainTab'] = self.view self.network_manager = CustomNetworkAccessManager.getInstance() self.navigator = Navigator.getInstance() self.route_node = YahooRouteNode.getInstance() self.graph_parser = GraphParser.getInstance() self.page.setNetworkAccessManager(self.network_manager) def loadConfig(self,config_file): self.config.read(config_file) def loadParam(self,name,value): name = name.strip() # print 'get param [%s]' % name if not self.config.has_section('PARAMS'): # print 'cree la seccion' self.config.add_section('PARAMS') self.config.set('PARAMS',name.strip(),value) # print 'seteo %s a %s ' % (name,value) def getParam(self,name,default=None): name = name.strip() # print 'get param [%s]' % name if self.config.has_section('PARAMS') and \ self.config.has_option('PARAMS',name): # print 'get param 1 %s' % name return self.config.get('PARAMS',name) if default != None: return default return None def toggleDelegationPolicy(self, delegate=None): if self.page.linkDelegationPolicy() == QWebPage.DontDelegateLinks or \ ( isinstance(delegate,bool) and delegate ): self.logger.info('cambio a delegate links') self.page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks) elif self.page.linkDelegationPolicy() == QWebPage.DelegateAllLinks or \ ( isinstance(delegate,bool) and not delegate ): self.logger.info('cambio a dont delegate links') self.page.setLinkDelegationPolicy(QWebPage.DontDelegateLinks) else: self.logger.warn("Can't set delegation policy") def setGraph(self,filename): self.graph_file = filename def start(self): self.logger.info('---------------------------- Jaime start work ---------------------------------') self.logger.info('Graph file = %s' % self.graph_file) if self.config.has_section('PARAMS') : self.logger.info('[PARAMS]') for name,value in self.config.items('PARAMS'): self.logger.info(' %s = %s' % (name,value)) self.page.setNetworkAccessManager(self.network_manager) self.page.loadFinished.connect(self.navigator.processPageLoadFinished) self.page.loadStarted.connect(self.navigator.processLoadStarted) self.page.linkClicked.connect(self.openLinkOnTab) self.close_tab_timer.timeout.connect(self.closeOpenTab) self.graph_parser.loadGraph(self.graph_file) if not self.navigator.takeEntryPoint(): self.finishWork() self.tabs_widget.show() # self.tabs_widget.showMaximized() def finishWork(self): self.logger.info('Jaime termina su funcionamiento') QApplication.closeAllWindows() def openLinkOnTab(self,link): l = len(self.tabs) new_tab_key = 'newTab_%s' % time.time() self.tabs[new_tab_key] = QWebView() self.tabs[new_tab_key].load(link) self.tabs_widget.insertTab(self.tabs_widget.count(),self.tabs[new_tab_key],new_tab_key) if self.close_tab_timer.timerId() == -1 : self.logger.info('starteo el close_tab_timer') self.close_tab_timer.start() def closeOpenTab(self): if len(self.tabs) == 1 and self.close_tab_timer.timerId() != -1 : self.logger.info('stopeo el close_tab_timer') self.close_tab_timer.stop() return ks = self.tabs.keys() ks.remove('mainTab') ks.sort() last_key = ks[0] index = None for i in range(len(self.tabs)): if self.tabs_widget.tabText(i) == last_key: index = i break if index: del self.tabs[last_key] self.tabs_widget.removeTab(index) else: # print 'stopeo el close_tab_timer' self.logger.error('no se encontro tab para remover con nombre %s' % last_key)
class Browser(object): def __init__(self, callback, logger, options=None): self.logger = logger self._request_ops = {'head': QNetworkAccessManager.HeadOperation, 'get': QNetworkAccessManager.GetOperation, 'put': QNetworkAccessManager.PutOperation, 'post': QNetworkAccessManager.PostOperation, 'delete': QNetworkAccessManager.DeleteOperation} self._network_manager = NetworkManager(logger) self._web_page = QWebPage() self._web_page.setNetworkAccessManager(self._network_manager) self._web_view = QWebView() self._web_view.setPage(self._web_page) # connect the loadFinished signal to a method defined by us. # loadFinished is the signal which is triggered when a page is loaded self._web_view.loadFinished.connect(self._load_finished) options = options or dict() settings = self._web_view.settings() settings.setAttribute(QWebSettings.AutoLoadImages, options.pop('images', False)) settings.setAttribute(QWebSettings.JavascriptEnabled, options.pop('javascript', False)) settings.setAttribute(QWebSettings.JavascriptCanOpenWindows, options.pop('popups', False)) settings.setAttribute(QWebSettings.PrivateBrowsingEnabled, options.pop('private_browsing', False)) settings.setAttribute(QWebSettings.JavaEnabled, False) settings.setAttribute(QWebSettings.PluginsEnabled, False) settings.setAttribute(QWebSettings.DnsPrefetchEnabled, True) # store the callback function which will be called when a request is # finished self._result_callback = callback def _prepare_request(self, url, headers): # create an empty request request = QNetworkRequest() # assign a url to it request.setUrl(QUrl(url)) # add some custom headers to the request for (header_name, header_value) in headers.items(): request.setRawHeader(header_name, QByteArray(header_value)) return request def _urlencode_request_data(self, raw_data): # the data which we want to send to the server must be urlencoded request_data = QUrl() for (name, value) in raw_data.items(): request_data.addQueryItem(name, unicode(value)) return request_data.encodedQuery() def _load_finished(self, ok): """ Called when the page is fully loaded. It will get the html file of the loaded page and call the callback function with that result. """ frame = self._web_view.page().mainFrame() url = smart_str(frame.url().toString()) html = frame.toHtml() result = {'html': html, 'url': url, 'successful': ok} if self._network_manager.errors: result['errors'] = self._network_manager.errors # calling the callback function which we passed upon instantiation to # report the results there self._result_callback(result) def make(self, method, url, headers, raw_data=None): request = self._prepare_request(url, headers) operation = self._request_ops[method.lower()] request_data = self._urlencode_request_data(raw_data or dict()) self._web_view.load(request, operation, request_data)