Пример #1
8
    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_()
Пример #2
0
    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
Пример #3
0
    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)
Пример #4
0
	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 )
Пример #5
0
    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())
Пример #6
0
    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_()
Пример #7
0
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()
Пример #8
0
 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)))
Пример #10
0
 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)
Пример #11
0
    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
Пример #12
0
	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
Пример #13
0
    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())
Пример #14
0
    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)))   
Пример #16
0
    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)
Пример #17
0
    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))))
Пример #18
0
    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)
Пример #19
0
    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_()
Пример #20
0
    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)
Пример #21
0
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)
Пример #22
0
 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...")
Пример #23
0
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)
Пример #24
0
    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
Пример #27
0
 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)))
Пример #28
0
    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)
Пример #29
0
    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)
Пример #30
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()
Пример #31
0
    def __init__(self, parent=None):
        self.client = parent
        self.nam = QNetworkAccessManager()

        self.nam.finished.connect(self.finishedDownload)

        self.modRequests = {}
        self.mapRequests = {}
        self.mapRequestsItem = []
Пример #32
0
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())
Пример #33
0
    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())
Пример #34
0
 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)
Пример #35
0
Файл: webkit.py Проект: qyb/sohu
    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)
Пример #36
0
 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)
Пример #37
0
 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()
Пример #38
0
	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())
Пример #39
0
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())
Пример #40
0
    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)
Пример #41
0
    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.")
Пример #42
0
	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)
Пример #43
0
    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()))
Пример #44
0
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)
Пример #45
0
 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)
Пример #46
0
 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
Пример #47
0
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))
Пример #48
0
    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))
Пример #49
0
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
Пример #50
0
    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
Пример #51
0
    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
Пример #52
0
    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)
Пример #53
0
 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)
Пример #54
0
 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
Пример #55
0
    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))))
Пример #56
0
    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
Пример #57
0
 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 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
Пример #59
0
	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