def setUpClass(cls): """Run before all tests""" # Create test layer srcpath = os.path.join(TEST_DATA_DIR, 'provider') cls.basetestfile = os.path.join(srcpath, 'delimited_wkt.csv') url = QUrl.fromLocalFile(cls.basetestfile) url.addQueryItem("crs", "epsg:4326") url.addQueryItem("type", "csv") url.addQueryItem("wktField", "wkt") url.addQueryItem("spatialIndex", "no") url.addQueryItem("subsetIndex", "no") url.addQueryItem("watchFile", "no") cls.vl = QgsVectorLayer(url.toString(), u'test', u'delimitedtext') assert cls.vl.isValid(), "{} is invalid".format(cls.basetestfile) cls.provider = cls.vl.dataProvider() cls.basetestpolyfile = os.path.join(srcpath, 'delimited_wkt_poly.csv') url = QUrl.fromLocalFile(cls.basetestpolyfile) url.addQueryItem("crs", "epsg:4326") url.addQueryItem("type", "csv") url.addQueryItem("wktField", "wkt") url.addQueryItem("spatialIndex", "no") url.addQueryItem("subsetIndex", "no") url.addQueryItem("watchFile", "no") cls.vl_poly = QgsVectorLayer(url.toString(), u'test_polygon', u'delimitedtext') assert cls.vl_poly.isValid(), "{} is invalid".format(cls.basetestpolyfile) cls.poly_provider = cls.vl_poly.dataProvider()
def __getReply(self, params): url = QUrl('http://ws.audioscrobbler.com/2.0/') url.addQueryItem('api_key', self.__last_fm_key) for key, value in params.iteritems(): url.addQueryItem(key, value) request = QNetworkRequest(url) return self.__networkManager.get(request)
class DownloadFtp(Download): def __init__(self, file_share, local_path, date): Download.__init__(self, file_share, local_path, date) self.ftp = QFtp(self) self.ftp.dataTransferProgress.connect(self.update_progress) self.ftp.done.connect(self.download_finished) self.ftp.stateChanged.connect(self.state_changed) self.url = QUrl(self._file_share.url) self.out_file = QFile(self.local_path) self.read_bytes = self.out_file.size() def start_download(self): self.ftp.connectToHost(self.url.host(), self.url.port(21)) self.ftp.login() if self.out_file.open(QIODevice.WriteOnly): self.ftp.get(self.url.path(), self.out_file) def stop(self): self.ftp def state_changed(self, state): if state == 1 or state == 2: self._state = 1 def download_finished(self, _): print "finished !" def update_progress(self, read_bytes, total_bytes): self.read_bytes = read_bytes
def setup(self, parent=None, caption=str("Sélectionnez")) : self.setFileMode(self.ExistingFiles) icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(_fromUtf8("resources/PL128.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.setWindowIcon(icon) mydir = str(os.environ['USERPROFILE']) thedir = QDir("C:/") self.setDirectory(thedir) url = [] url.append(QUrl.fromLocalFile(QDesktopServices.storageLocation(QDesktopServices.DocumentsLocation))) url.append(QUrl.fromLocalFile(QDesktopServices.storageLocation(QDesktopServices.DesktopLocation))) url.append(QUrl.fromLocalFile(QDesktopServices.storageLocation(QDesktopServices.HomeLocation))) url.append(QUrl('file:')) self.setSidebarUrls(url) # self.setDirectory(mydir) self.setWindowModality(QtCore.Qt.ApplicationModal) MyFileDialog.setNameFilter(self, "Epub (*.epub)") self.setLabelText(self.LookIn, "Regarder dans :") self.setLabelText(self.FileName, "Fichier") self.setLabelText(self.FileType, "Type de fichier") self.setLabelText(self.Accept, "Ouvrir") self.setLabelText(self.Reject, "Annuler") self.setWindowTitle("Sélectionnez un ou plusieurs fichiers") self.setOption(self.DontUseNativeDialog, False) # self.setOption(self.DontResolveSymlinks, True) self.setOption(self.ShowDirsOnly, False) self.tree = self.findChild(QtGui.QTreeView) self.init_ui() self.filesSelected.connect(self.cur_change) self.filesSelected.connect(self.choose_file)
def load(self, url=None, encoding=None, keepUndo=False): """Load the specified or current url (if None was specified). Currently only local files are supported. An IOError is raised when trying to load a nonlocal URL. If loading succeeds and an url was specified, the url is make the current url (by calling setUrl() internally). If keepUndo is True, the loading can be undone (with Ctrl-Z). """ if url is None: url = QUrl() u = url if not url.isEmpty() else self.url() text = self.load_data(u, encoding or self._encoding) if keepUndo: c = QTextCursor(self) c.select(QTextCursor.Document) c.insertText(text) else: self.setPlainText(text) self.setModified(False) if not url.isEmpty(): self.setUrl(url) self.loaded() app.documentLoaded(self)
def command(self, command): """Perform one command.""" command = command.split() cmd = command[0] args = command[1:] win = QApplication.activeWindow() if win not in app.windows: if not app.windows: import mainwindow mainwindow.MainWindow().show() win = app.windows[0] if cmd == b'open': url = QUrl.fromEncoded(args[0]) win.openUrl(url, self.encoding) elif cmd == b'encoding': self.encoding = str(args[0]) elif cmd == b'activate_window': win.activateWindow() win.raise_() elif cmd == b'set_current': url = QUrl.fromEncoded(args[0]) win.setCurrentDocument(app.openUrl(url, self.encoding)) elif cmd == b'set_cursor': line, column = map(int, args) cursor = win.textCursor() pos = cursor.document().findBlockByNumber(line - 1).position() + column cursor.setPosition(pos) win.currentView().setTextCursor(cursor) elif cmd == b'bye': self.close()
def downloadFile(self, url, archivo_destino): url = QUrl(url) fileName = archivo_destino directorio_usuario_para_pilas = os.path.dirname(archivo_destino) if not os.path.exists(directorio_usuario_para_pilas): os.mkdir(directorio_usuario_para_pilas) if QFile.exists(fileName): QFile.remove(fileName) self.outFile = QFile(fileName) if not self.outFile.open(QIODevice.WriteOnly): QMessageBox.information(self, 'Error', 'Lo siento, no se puede descargar el archivo desde %s: %s.' % (self.url, self.outFile.errorString())) self.outFile = None return mode = QHttp.ConnectionModeHttp port = url.port() if port == -1: port = 0 self.http.setHost(url.host(), mode, port) self.httpRequestAborted = False path = QUrl.toPercentEncoding(url.path(), "!$&'()*+,;=:@/") if path: path = str(path) else: path = '/' self.httpGetId = self.http.get(path, self.outFile)
def save(self, url=None, encoding=None): """Saves the document to the specified or current url. Currently only local files are supported. An IOError is raised when trying to save a nonlocal URL. If saving succeeds and an url was specified, the url is made the current url (by calling setUrl() internally). """ if url is None: url = QUrl() u = url if not url.isEmpty() else self.url() filename = u.toLocalFile() # currently, we do not support non-local files if not filename: raise IOError("not a local file") # keep the url if specified when we didn't have one, even if saving # would fail if self.url().isEmpty() and not url.isEmpty(): self.setUrl(url) with app.documentSaving(self): with open(filename, "wb") as f: f.write(self.encodedText()) f.flush() os.fsync(f.fileno()) self.setModified(False) if not url.isEmpty(): self.setUrl(url) self.saved() app.documentSaved(self)
def showPackage(self, item): row = item.row() tmp = self.packageTable.item(row, 1) package = tmp.text() home = QUrl(self.home) curr = QUrl("../../library/%s/html/00Index.html" % package) self.htmlViewer.setSource(home.resolved(curr))
def downloadFile(self): url = QUrl(self.url_to_download) fileName = QFileDialog.getSaveFileName(self, "Enregistrer la liste des dossiers", self.nameFile, "conf") if QFile.exists(fileName): QFile.remove(fileName) self.outFile = QFile(fileName) if not self.outFile.open(QIODevice.WriteOnly): QMessageBox.information(self, 'Erreur','Impossible d\'enregistrer le fichier %s: %s.' % (fileName, self.outFile.errorString())) self.outFile = None return #Création que la connexion HTTPS mode = QHttp.ConnectionModeHttps port = 0 self.http.setHost(url.host(), mode, port) self.requeteHTTPannule = False path = QUrl.toPercentEncoding(url.path(), "!$&'()*+,;=:@/") if path: path = str(path) else: path = '/' #Concaténation des paramètres à l'URL path = path+("?") for item in url.queryItems(): path = path + item[0] + "=" + item[1] + "&" self.http.setUser(self.login, self.password) self.httpGetId = self.http.get(path, self.outFile)
def createRequest(self, op, req, data): #print "createRequest: req.url()", req.url() if req.url().host() != "webodf": return super(WebODFNetworkManager, self).createRequest(op, req, data); path = QUrl("http://webodf/").resolved(req.url()).path() print "Request for", path if op == QNetworkAccessManager.GetOperation: reply = None; if path.startswith("/dijit"): path = "/wodo" + path # TODO: why gets wodo/ lost? resourcePath = Resources.get("documentsharing"+path) if os.path.exists(resourcePath): print "reply for resource:", resourcePath reply = ResourceReply(resourcePath, self) elif path == self.genesisDocumentPath: print "reply for genesis document:", self.genesisDocumentPath reply = ResourceReply(self.genesisDocumentPath, self) else: avatarUrl = self.sessionBackend.resolveAvatarUrl(path) if avatarUrl != "": print "reply for avatar url:", avatarUrl reply = ResourceReply(avatarUrl, self) if reply is not None: return reply print "Request for unknown resource:", path return super(WebODFNetworkManager, self).createRequest(op, req, data)
def from_user_input(userInput): # Toma una URL en string y la transforma a un QUrl bien formado userInput = QString(userInput) trimmedString = userInput.trimmed() url = QUrl.fromEncoded(trimmedString.toUtf8(), QUrl.TolerantMode) urlPrepended = QUrl.fromEncoded((QLatin1String("http://") + trimmedString).toUtf8(), QUrl.TolerantMode) # Check the most common case of a valid url with scheme and host # We check if the port would be valid by adding the scheme to handle the case host:port # where the host would be interpretted as the scheme if (url.isValid() and not url.scheme().isEmpty() and (not url.host().isEmpty() or not url.path().isEmpty()) and urlPrepended.port() == -1): return url # Else, try the prepended one and adjust the scheme from the host name if (urlPrepended.isValid() and (not urlPrepended.host().isEmpty() or not urlPrepended.path().isEmpty())): dotIndex = trimmedString.indexOf(".") hostscheme = trimmedString.left(dotIndex).toLower() if (hostscheme == QLatin1String("ftp")): urlPrepended.setScheme(QLatin1String("ftp")) return urlPrepended return QUrl()
def test_rowid(self): source = QUrl.toPercentEncoding(os.path.join(self.testDataDir, "france_parts.shp")) query = QUrl.toPercentEncoding("select rowid as uid, * from vtab limit 1 offset 3") l = QgsVectorLayer("?layer=ogr:%s:vtab&query=%s" % (source, query), "vtab2", "virtual", False) # the last line must have a fixed rowid (not an autoincrement) for f in l.getFeatures(): lid = f.attributes()[0] self.assertEqual(lid, 3)
def load_account_page(self, account, tab=None, task=None): self.tab = tab self.task = task self.account = account url = QUrl(account.server.settings_url) for name, value in self.query_items: url.addQueryItem(name, value) self.load(url)
def email(subject, body): """Opens the e-mail composer with the given subject and body, with version information added to it.""" subject = "[{0} {1}] {2}".format(appinfo.appname, appinfo.version, subject) body = "{0}\n\n{1}\n\n".format(debuginfo.version_info_string(' -- '), body) url = QUrl("mailto:" + appinfo.maintainer_email) url.addQueryItem("subject", subject) url.addQueryItem("body", body) helpers.openUrl(url, "email")
def dropEvent(self, e): logger.debug(msg("Drag drop event")) file_url = QUrl(e.mimeData().text()) if file_url.isValid() and file_url.isLocalFile(): fname = file_url.toLocalFile() if fname in self.watcher.files(): logger.debug(msg("already watching file", fname)) else: self.watch_file(file_url.toLocalFile())
def test_filter_rect(self): source = QUrl.toPercentEncoding(os.path.join(self.testDataDir, "france_parts.shp")) query = QUrl.toPercentEncoding("select * from vtab where _search_frame_=BuildMbr(-2.10,49.38,-1.3,49.99,4326)") l2 = QgsVectorLayer("?layer=ogr:%s:vtab&query=%s&uid=objectid" % (source, query), "vtab2", "virtual", False) self.assertEqual(l2.isValid(), True) self.assertEqual(l2.dataProvider().featureCount(), 1) a = [fit.attributes()[4] for fit in l2.getFeatures()] self.assertEqual(a, [u"Basse-Normandie"])
def test_sql2(self): l2 = QgsVectorLayer(os.path.join(self.testDataDir, "france_parts.shp"), "france_parts", "ogr", False) self.assertEqual(l2.isValid(), True) QgsMapLayerRegistry.instance().addMapLayer(l2) query = QUrl.toPercentEncoding("SELECT * FROM france_parts") l4 = QgsVectorLayer("?query=%s" % query, "tt", "virtual") self.assertEqual(l4.isValid(), True) self.assertEqual(l4.dataProvider().geometryType(), 3) self.assertEqual(l4.dataProvider().crs().postgisSrid(), 4326) n = 0 r = QgsFeatureRequest(QgsRectangle(-1.677, 49.624, -0.816, 49.086)) for f in l4.getFeatures(r): self.assertEqual(f.geometry() is not None, True) self.assertEqual(f.attributes()[0], 2661) n += 1 self.assertEqual(n, 1) # use uid query = QUrl.toPercentEncoding("SELECT * FROM france_parts") l5 = QgsVectorLayer("?query=%s&geometry=geometry:polygon:4326&uid=ObjectId" % query, "tt", "virtual") self.assertEqual(l5.isValid(), True) idSum = sum(f.id() for f in l5.getFeatures()) self.assertEqual(idSum, 10659) r = QgsFeatureRequest(2661) idSum2 = sum(f.id() for f in l5.getFeatures(r)) self.assertEqual(idSum2, 2661) r = QgsFeatureRequest() r.setFilterFids([2661, 2664]) self.assertEqual(sum(f.id() for f in l5.getFeatures(r)), 2661 + 2664) # test attribute subset r = QgsFeatureRequest() r.setFlags(QgsFeatureRequest.SubsetOfAttributes) r.setSubsetOfAttributes([1]) s = [(f.id(), f.attributes()[1]) for f in l5.getFeatures(r)] self.assertEqual(sum(map(lambda x: x[0], s)), 10659) self.assertEqual(sum(map(lambda x: x[1], s)), 3064.0) # test NoGeometry # by request flag r = QgsFeatureRequest() r.setFlags(QgsFeatureRequest.NoGeometry) self.assertEqual(all([f.geometry() is None for f in l5.getFeatures(r)]), True) # test subset self.assertEqual(l5.dataProvider().featureCount(), 4) l5.setSubsetString("ObjectId = 2661") idSum2 = sum(f.id() for f in l5.getFeatures(r)) self.assertEqual(idSum2, 2661) self.assertEqual(l5.dataProvider().featureCount(), 1)
def startmain(): import optparse optparse._ = _ # let optparse use our translations parser = optparse.OptionParser( usage = _("{appname} [options] file ...").format(appname=info.name), version = "{0} {1}".format(info.appname, info.version), description = _("A LilyPond Music Editor")) parser.add_option('-e', '--encoding', metavar=_("ENC"), help=_("Encoding to use")) parser.add_option('-l', '--line', type="int", metavar=_("NUM"), help=_("Line number to go to, starting at 1")) parser.add_option('-c', '--column', type="int", metavar=_("NUM"), help=_("Column to go to, starting at 0"), default=0) parser.add_option('--start', metavar=_("NAME"), help=_("Session to start ('{none}' for empty session)").format(none="none"), dest="session") args = QApplication.arguments() if os.name == 'nt' and args and 'python' in os.path.basename(args[0]).lower(): args = args[2:] else: args = args[1:] options, files = parser.parse_args(args) # load specified session doc = None if options.session and options.session != "none": doc = sessions.loadSession(options.session) # Just create one MainWindow win = mainwindow.MainWindow() win.show() if files: # make urls for arg in files: if re.match(r'^(https?|s?ftp)://', arg): url = QUrl(arg) elif arg.startswith('file://'): url = QUrl.fromLocalFile(arg[7:]) elif arg.startswith('file:'): url = QUrl.fromLocalFile(os.path.abspath(arg[5:])) else: url = QUrl.fromLocalFile(os.path.abspath(arg)) doc = win.openUrl(url, options.encoding) elif not options.session: # no docs, load default session doc = sessions.loadDefaultSession() win.setCurrentDocument(doc or document.Document()) if files and options.line is not None: # set the last loaded document active and apply navigation if requested pos = doc.findBlockByNumber(options.line - 1).position() + options.column cursor = QTextCursor(doc) cursor.setPosition(pos) win.currentView().setTextCursor(cursor) win.currentView().centerCursor()
def logo_element(): """Create a sanitised local url to the logo for insertion into html. :returns: A sanitised local url to the logo. :rtype: str """ path = os.path.join(resources_path(), 'img', 'logos', 'inasafe-logo.png') url = QUrl(path) path = url.toLocalFile() return path
def test_DynamicGeometry(self): l1 = QgsVectorLayer(QUrl.fromLocalFile(os.path.join(self.testDataDir, "delimitedtext/testextpt.txt")).toString() + "?type=csv&delimiter=%7C&geomType=none&subsetIndex=no&watchFile=no", "test", "delimitedtext", False) self.assertEqual(l1.isValid(), True) QgsMapLayerRegistry.instance().addMapLayer(l1) query = QUrl.toPercentEncoding("select *,makepoint(x,y) as geom from vtab1") l2 = QgsVectorLayer("?layer_ref=%s&query=%s&geometry=geom:point:0&uid=id" % (l1.id(), query), "vtab", "virtual", False) self.assertEqual(l2.isValid(), True) QgsMapLayerRegistry.instance().removeMapLayer(l1)
def test_reopen2(self): source = QUrl.toPercentEncoding(os.path.join(self.testDataDir, "france_parts.shp")) tmp = QUrl.fromLocalFile(os.path.join(tempfile.gettempdir(), "t.sqlite")).toString() l = QgsVectorLayer("%s?layer=ogr:%s:vtab&nogeometry" % (tmp, source), "vtab2", "virtual", False) self.assertEqual(l.isValid(), True) l2 = QgsVectorLayer(tmp, "tt", "virtual", False) self.assertEqual(l2.isValid(), True) self.assertEqual(l2.dataProvider().geometryType(), 100) self.assertEqual(l2.dataProvider().featureCount(), 4)
def test_refLayers2(self): l1 = QgsVectorLayer(QUrl.fromLocalFile(os.path.join(self.testDataDir, "delimitedtext/test.csv")).toString() + "?type=csv&geomType=none&subsetIndex=no&watchFile=no", "test", "delimitedtext", False) self.assertEqual(l1.isValid(), True) QgsMapLayerRegistry.instance().addMapLayer(l1) # referenced layers cannot be stored ! tmp = QUrl.fromLocalFile(os.path.join(tempfile.gettempdir(), "t.sqlite")).toString() l2 = QgsVectorLayer("%s?layer_ref=%s" % (tmp, l1.id()), "tt", "virtual", False) self.assertEqual(l2.isValid(), False) self.assertEqual("Cannot store referenced layers" in l2.dataProvider().error().message(), True)
def url(arg): """Converts a filename-like argument to a QUrl.""" if re.match(r'^(https?|s?ftp)://', arg): return QUrl(arg) elif arg.startswith('file://'): return QUrl.fromLocalFile(os.path.abspath(arg[7:])) elif arg.startswith('file:'): return QUrl.fromLocalFile(os.path.abspath(arg[5:])) else: return QUrl.fromLocalFile(os.path.abspath(arg))
def _render_header(title, mode, phrase, filters): r = [] r.append(ADV_HEADER) r.append('<h1>{0}</h1>'.format(title)) r.append('<ul class="nav">\n') modes = [(name, spec) for (name, spec) in MODE_DICT.items()] modes.sort(key=itemgetter(0)) for (name, spec) in modes: href = QUrl('search:///') if phrase: href.addQueryItem('phrase', phrase) if filters: href.addQueryItem('filters', filters) href.addQueryItem('mode', name) if name != mode: r.append( '<li><a href="{href}">{title}</a></li>\n'.format( href=href.toEncoded(), title=spec['title'])) else: r.append( '<li><span class="sel">{title}<span></li>\n'.format( href=href.toEncoded(), title=spec['title'])) r.append('</ul>\n') return ''.join(r)
class DelayNagvisWidget(DelayWidget): def __init__(self, name, cfg, parent = None): DelayWidget.__init__(self, name, cfg, parent) self.realUrl = QUrl() self.realUrl.setUrl(self.config.loadLinks()[str(self.objectName())]['data']) def resizeEvent(self, event): self.url.setUrl('%s&width=%d&height=%d' % (self.realUrl.toString(), self.width()/self.webView.zoomFactor()-20, self.height()/self.webView.zoomFactor()-65))
def _sendRequest(self, url, params): if self.asynchonous: url = QUrl(url) for key, value in params.iteritems(): url.addQueryItem(key, value) request = QNetworkRequest(url) self.reply = self.manager.get(request) else: response = urllib2.urlopen(self.url + '?' + urllib.urlencode(params)) data = json.load(response) self.loadData(data)
def onNameSelectChange(self): try: l = self.links[str(self.nameSelect.currentText())] u = QUrl(l['data']) self.name.setText(u.userName()) self.passwd.setText(u.password()) self.urlEdit.setText(u.toString(QUrl.RemoveUserInfo)) self.typeSelect.setCurrentIndex(self.typeSelect.findText(l['type'])) except Exception as e: #print e pass
def test1(self): d = QgsVirtualLayerDefinition() self.assertEqual(d.toString(), "") d.setFilePath("/file") self.assertEqual(d.toString(), "file:///file") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).filePath(), "/file") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).filePath(), "/file") d.setFilePath("C:\\file") self.assertEqual(d.toString(), "file:///C:%5Cfile") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).filePath(), "C:\\file") d.setQuery("SELECT * FROM mytable") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).query(), "SELECT * FROM mytable") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).query(), "SELECT * FROM mytable") q = u"SELECT * FROM tableéé /*:int*/" d.setQuery(q) self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).query(), q) self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).query(), q) s1 = u"file://foo&bar=okié" d.addSource("name", s1, "provider", "utf8") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).sourceLayers()[0].source(), s1) self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).sourceLayers()[0].source(), s1) n1 = u"éé ok" d.addSource(n1, s1, "provider") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).sourceLayers()[1].name(), n1) self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).sourceLayers()[1].name(), n1) d.addSource("ref1", "id0001") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).sourceLayers()[2].reference(), "id0001") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).sourceLayers()[2].reference(), "id0001") s = "dbname='C:\\tt' table=\"test\" (geometry) sql=" d.addSource("nn", s, "spatialite") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).sourceLayers()[3].source(), s) self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).sourceLayers()[3].source(), s) d.setGeometryField("geom") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).geometryField(), "geom") self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).geometryField(), "geom") d.setGeometryWkbType(QgsWKBTypes.Point) self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).geometryWkbType(), QgsWKBTypes.Point) self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).geometryWkbType(), QgsWKBTypes.Point) f = QgsFields() f.append(QgsField("a", QVariant.Int)) f.append(QgsField("f", QVariant.Double)) f.append(QgsField("s", QVariant.String)) d.setFields(f) f2 = QgsVirtualLayerDefinition.fromUrl(d.toUrl()).fields() self.assertEqual(f[0].name(), f2[0].name()) self.assertEqual(f[0].type(), f2[0].type()) self.assertEqual(f[1].name(), f2[1].name()) self.assertEqual(f[1].type(), f2[1].type()) self.assertEqual(f[2].name(), f2[2].name()) self.assertEqual(f[2].type(), f2[2].type())
def extract_domain(hstr, qstr=True): if not isinstance(hstr, QUrl): hstr = QUrl(hstr) hstr = hstr.authority() if not isinstance(hstr, unicode): hstr = unicode(hstr) if '.' not in hstr or REGEXP_IP_ADDRESS.match(hstr): return QString(hstr) if qstr else hstr hstr = hstr.split('.') lhstr = len(hstr) hstr = hstr[lhstr-2] + '.' + hstr[lhstr-1] return QString(hstr) if qstr else hstr
def __init__(self, layer, settingsdict={}): #show the user this may take a long time... QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) self.settingsdict = settingsdict provider = layer.dataProvider() # OGR provider kolumnindex = provider.fieldNameIndex( 'obsid') # To find the column named 'obsid' observations = layer.selectedFeatures() reportfolder = os.path.join(QDir.tempPath(), 'midvatten_reports') if not os.path.exists(reportfolder): os.makedirs(reportfolder) reportpath = os.path.join(reportfolder, "w_qual_report.html") #f = open(reportpath, "wb" ) f = codecs.open(reportpath, "wb", "utf-8") #write some initiating html rpt = r"""<head><title>%s</title></head>""" % ru( QCoreApplication.translate( u'Wqualreport', u'water quality report from Midvatten plugin for QGIS')) rpt += r""" <meta http-equiv="content-type" content="text/html; charset=utf-8" />""" #NOTE, all report data must be in 'utf-8' rpt += "<html><body>" #rpt += "<table width=\"100%\" border=\"1\">\n" #rpt2 = rpt.encode("utf-8") f.write(rpt) dbconnection = db_utils.DbConnectionManager() for i, object in enumerate(observations): attributes = observations[i] obsid = attributes[kolumnindex] try: print('about to get data for ' + obsid + ', at time: ' + str(time.time())) #debug except: pass ReportData = self.GetData( self.settingsdict['database'], obsid, dbconnection) # one observation at a time try: print('done with getting data for ' + obsid + ', at time: ' + str(time.time())) #debug except: pass if ReportData: self.WriteHTMLReport(ReportData, f) try: print('wrote html report for ' + obsid + ', at time: ' + str(time.time())) #debug except: pass dbconnection.closedb() #write some finishing html and close the file f.write("\n</body></html>") f.close() QApplication.restoreOverrideCursor( ) #now this long process is done and the cursor is back as normal if ReportData: QDesktopServices.openUrl(QUrl.fromLocalFile(reportpath))
def loadTestSite(self): #url = QUrl("file:///home/mlatu/work/saltyStele/test.html") url = QUrl("file:///d:/test.html") self.browser.load(url)
def _open_url(url): QDesktopServices.openUrl(QUrl(url))
def __init__(self, parent=None, bridge=None, options=None, *, highchart='Chart', enable_zoom=False, enable_select=False, selection_callback=None, javascript='', debug=False, **kwargs): options = (options or {}).copy() enable_select = enable_select or '' if not isinstance(options, dict): raise ValueError('options must be dict') if enable_select not in ('', '+', 'x', 'y', 'xy', 'x+', 'y+', 'xy+'): raise ValueError("enable_select must be '+', 'x', 'y', or 'xy'") if enable_select and not selection_callback: raise ValueError('enable_select requires selection_callback') super().__init__(parent, bridge, debug=debug, url=QUrl(self._HIGHCHARTS_HTML)) self.debug = debug self.highchart = highchart self.enable_zoom = enable_zoom enable_point_select = '+' in enable_select enable_rect_select = enable_select.replace('+', '') if enable_zoom: _merge_dicts( options, _kwargs_options( dict(mapNavigation_enableMouseWheelZoom=True, mapNavigation_enableButtons=False))) if enable_select: self._selection_callback = selection_callback self.frame.addToJavaScriptWindowObject('__highchart', self) _merge_dicts( options, _kwargs_options( dict(chart_events_click='/**/unselectAllPoints/**/'))) if enable_point_select: _merge_dicts( options, _kwargs_options( dict(plotOptions_series_allowPointSelect=True, plotOptions_series_point_events_click= '/**/clickedPointSelect/**/'))) if enable_rect_select: _merge_dicts( options, _kwargs_options( dict(chart_zoomType=enable_rect_select, chart_events_selection='/**/rectSelectPoints/**/'))) if kwargs: _merge_dicts(options, _kwargs_options(kwargs)) self.frame.loadFinished.connect(lambda: self.evalJS(''' {javascript}; var options = {options}; fixupOptionsObject(options); Highcharts.setOptions(options); '''.format(javascript=javascript, options=json(options)))) # Give above scripts time to load qApp.processEvents(QEventLoop.ExcludeUserInputEvents) qApp.processEvents(QEventLoop.ExcludeUserInputEvents)
def openfolder(folder): """ Open a folder using the OS :param folder: The path to the folder to open. """ QDesktopServices.openUrl(QUrl.fromLocalFile(folder))
def htmlUrl(self): """Helper to get the url of the html doc.""" myPath = os.path.join(TEST_DATA_DIR, "html_table.html") myUrl = QUrl("file:///" + myPath) return myUrl
def openHelpURL(self, q_string): url = QUrl(q_string) QDesktopServices.openUrl(url)
def load(self, url): self.page.mainFrame().setUrl(QUrl(url))
def openfolder(folder): QDesktopServices.openUrl(QUrl.fromLocalFile(folder))
def _return_pressed(self): url = QUrl(self.text()) browser.load(url)
def print_impact_table(self, output_path): """Pint summary from impact layer to PDF. ..note:: The order of the report: 1. Summary table 2. Aggregation table 3. Attribution table :param output_path: Output path. :type output_path: str :return: Path to generated pdf file. :rtype: str :raises: None """ keywords = self._keyword_io.read_keywords(self.layer) if output_path is None: output_path = unique_filename(suffix='.pdf', dir=temp_dir()) summary_table = keywords.get('impact_summary', None) full_table = keywords.get('impact_table', None) aggregation_table = keywords.get('postprocessing_report', None) attribution_table = impact_attribution(keywords) # (AG) We will not use impact_table as most of the IF use that as: # impact_table = impact_summary + some information intended to be # shown on screen (see FloodOsmBuilding) # Unless the impact_summary is None, we will use impact_table as the # alternative html = m.Brand().to_html() html += m.Heading(tr('Analysis Results'), **INFO_STYLE).to_html() if summary_table is None: html += full_table else: html += summary_table if aggregation_table is not None: html += aggregation_table if attribution_table is not None: html += attribution_table.to_html() html = html_header() + html + html_footer() # Print HTML using composition # For QGIS < 2.4 compatibility # QgsMapSettings is added in 2.4 if qgis_version() < 20400: map_settings = QgsMapRenderer() else: map_settings = QgsMapSettings() # A4 Portrait # TODO: Will break when we try to use larger print layouts TS paper_width = 210 paper_height = 297 # noinspection PyCallingNonCallable composition = QgsComposition(map_settings) # noinspection PyUnresolvedReferences composition.setPlotStyle(QgsComposition.Print) composition.setPaperSize(paper_width, paper_height) composition.setPrintResolution(300) # Add HTML Frame # noinspection PyCallingNonCallable html_item = QgsComposerHtml(composition, False) margin_left = 10 margin_top = 10 # noinspection PyCallingNonCallable html_frame = QgsComposerFrame(composition, html_item, margin_left, margin_top, paper_width - 2 * margin_left, paper_height - 2 * margin_top) html_item.addFrame(html_frame) # Set HTML # From QGIS 2.6, we can set composer HTML with manual HTML if qgis_version() < 20600: html_path = unique_filename(prefix='report', suffix='.html', dir=temp_dir()) html_to_file(html, file_path=html_path) html_url = QUrl.fromLocalFile(html_path) html_item.setUrl(html_url) else: # noinspection PyUnresolvedReferences html_item.setContentMode(QgsComposerHtml.ManualHtml) # noinspection PyUnresolvedReferences html_item.setResizeMode(QgsComposerHtml.RepeatUntilFinished) html_item.setHtml(html) # RMN: This line below breaks in InaSAFE Headless after one # successful call. This is because the function is not # thread safe. Can't do anything about this, so avoid calling this # function in multithreaded way. html_item.loadHtml() composition.exportAsPDF(output_path) return output_path
def setContent(self, data, mimetype, base_url=''): """Set the content `data` of type `mimetype` in the current webframe.""" super().setContent(data, mimetype, QUrl(base_url))
kakasi = KakasiController() mecab = MecabController() if USE_MECAB: mecab.ensureOpen() tool = mecab else: tool = kakasi addHook('fact.focusLost', onFocusLost) except Exception: if sys.platform.startswith("win32"): from PyQt4.QtGui import QDesktopServices from PyQt4.QtCore import QUrl from ankiqt.ui.utils import showInfo showInfo("Please install anki-reading.exe") QDesktopServices.openUrl( QUrl("http://ichi2.net/anki/wiki/JapaneseSupport")) raise # Ctrl+g shortcut, based on Samson's regenerate reading field plugin ########################################################################## def genReading(self): # make sure current text is saved self.saveFieldsNow() # find the first src field available reading = None for f in srcFields: try: reading = tool.reading(self.fact[f]) break
def _return_pressed(self): url = QUrl(self.text()) # load url into browser frame self.cb(url)
json_string = webURL.read() encoding = webURL.info().get_content_charset('utf-8') parsed_json = json.loads(json_string.decode(encoding)) temp_f = parsed_json['current_observation']['temp_c'] relative_humidity = parsed_json['current_observation']['relative_humidity'] wind_dir = parsed_json['current_observation']['wind_dir'] wind_kph = parsed_json['current_observation']['wind_kph'] self.ln_ctmp.setText(str(temp_f)) self.ln_relh.setText(str(relative_humidity)) self.ln_wndsp.setText(str(wind_kph)) self.ln_wnd.setText(str(wind_dir)) webURL.close() if __name__ == "__main__": print ("Operation started") #initdatabases() app = QtGui.QApplication(sys.argv) myWindow = MyWindowClass() myWindow.webView.load(QUrl('http://localhost/attendance/livedata')) scheduler.start() myWindow.showMaximized() sys.exit(app.exec_())
def simple_link_handler(url): u"""Play the file.""" if url.startswith("ankiplay"): play(url[8:]) else: QDesktopServices.openUrl(QUrl(url))
class NetworkMixin(object): """A mixin that can be used to send network request and receive replies.""" request_url = str error = None results = None def __init__(self, request_url, geojson=False): self.request_url = request_url self.manager = QgsNetworkAccessManager.instance() self.reply = None self.url = QUrl(self.request_url) self.req = QNetworkRequest(self.url) self.results = QByteArray() self.auth_token = get_authtoken() # Paginated data self._pagination_exhausted = False self.geojson = geojson if geojson: self.combine_new_data = self.combine_new_geojson_data def cancel_request(self): """Abort the request.""" self.reply.abort() def connect_request(self): """Process the request.""" LOGGER.info('Requesting "%s"', self.request_url) self.reply.readyRead.connect(self.connection_read_data) self.reply.finished.connect(self.connection_finished) self.reply.error.connect(self.connection_error) def connect_paginated_request(self, prev_data, callback): """Process the request of a paginated resource.""" LOGGER.info('Requesting "%s" (paginated)', self.request_url) self.reply.readyRead.connect(self.connection_read_data) self.reply.finished.connect( functools.partial(self._handle_paginated_data, prev_data, callback)) self.reply.error.connect(self.connection_error) def connect_get(self): """Send get request.""" if self.auth_token: # Add authentication token to request self.req.setRawHeader('Authorization', 'token %s' % self.auth_token) self.reply = self.manager.get(self.req) self.connect_request() def connect_post(self, data): """Send post request. :param data: Context data to use with template :type data: QByteArray """ if self.auth_token: # Add authentication token to request self.req.setRawHeader('Authorization', 'token %s' % self.auth_token) self.reply = self.manager.post(self.req, data) self.connect_request() def connect_json_post(self, data): """Send post request with json string. :param data: Json string data :type data: str """ if self.auth_token: # Add authentication token to request self.req.setRawHeader('Authorization', 'token %s' % self.auth_token) self.req.setRawHeader("Content-Type", "application/json") self.reply = self.manager.post(self.req, data) self.connect_request() def connect_json_put(self, data): """Send put request with json string. :param data: Json string data :type data: str """ if self.auth_token: # Add authentication token to request self.req.setRawHeader('Authorization', 'token %s' % self.auth_token) self.req.setRawHeader("Content-Type", "application/json") json_string = QByteArray(data) p_buffer = QBuffer(self.manager) p_buffer.setData(json_string) self.reply = self.manager.sendCustomRequest(self.req, 'PUT', p_buffer) self.connect_request() def connect_json_patch(self, data): """Send patch request with json string. :param data: Json string data :type data: str """ if self.auth_token: # Add authentication token to request self.req.setRawHeader('Authorization', 'token %s' % self.auth_token) self.req.setRawHeader("Content-Type", "application/json") json_string = QByteArray(data) p_buffer = QBuffer(self.manager) p_buffer.setData(json_string) self.reply = self.manager.sendCustomRequest(self.req, 'PATCH', p_buffer) self.connect_request() def connect_get_paginated(self, prev_data=None, callback=None): if self.auth_token: # Add authentication token to request self.req.setRawHeader('Authorization', 'token %s' % self.auth_token) self.reply = self.manager.get(self.req) self.connect_paginated_request( prev_data or self.results, callback or self._set_results_and_complete) def _handle_paginated_data(self, prev_data, callback): """ Once all data from single request is returned, merge it with previous responses and follow pagination. """ # Add new request's data to prev_data resp_txt = str(self.results) merged_data = self.combine_new_data(str(prev_data or ''), resp_txt) merged_data = QByteArray(merged_data) # Get next page next_url = None try: next_url = json.loads(resp_txt).get('next') except ValueError: pass if next_url: next_req = NetworkMixin(next_url, geojson=self.geojson) return next_req.connect_get_paginated(prev_data=merged_data, callback=callback) LOGGER.debug('Pagination finished at "%s"', self.request_url) callback(merged_data) def _set_results_and_complete(self, results): self.results = results self._pagination_exhausted = True self.connection_finished() @staticmethod def combine_new_data(old_data_str, new_data_str): """ Merge results from new page of data with results from previous pages of data. Expects a response in a format such as: { "count": 10, "next": null, "previous": null, "results": [ ... ] } """ old_data = '' new_data = '' try: old_data = json.loads(old_data_str or '[]') new_data = json.loads(new_data_str) except ValueError: pass results_new_data = [] if 'results' in new_data: results_new_data = new_data['results'] return json.dumps(old_data + results_new_data) @staticmethod def combine_new_geojson_data(old_data_str, new_data_str): """ Merge results from new page of GeoJSON data with results from previous pages of data. Expects a response in a format such as: { "count": 10, "next": null, "previous": null, "results": { "type": "FeatureCollection", "features": [ ... ] } } """ old_data = dict() new_data = dict() try: old_data = json.loads(old_data_str or '[]') new_data = json.loads(new_data_str) except ValueError: pass if not old_data and 'results' in new_data: return json.dumps(new_data['results']) if 'features' in old_data and 'results' in new_data: old_data['features'] += new_data['results']['features'] return json.dumps(old_data) def connection_read_data(self): """Get data from self.reply and append it to results.""" self.results += self.reply.readAll() def get_json_results(self): """Convert results to json object.""" return json.loads(str(self.results)) def connection_error(self): """Handle error connection.""" error_result = self.reply.error try: http_code = int( self.reply.attribute(QNetworkRequest.HttpStatusCodeAttribute)) except TypeError: http_code = None self.http_code = 404 if error_result == QNetworkReply.UnknownNetworkError: msg = 'The network is unreachable.' elif error_result == QNetworkReply.ProtocolUnknownError \ or error_result == QNetworkReply.HostNotFoundError: msg = 'Host not found : %s' % self.url.encodedHost() else: if http_code: msg = 'Error code:' + str(http_code) self.http_code = http_code else: msg = 'Can\'t find the server' LOGGER.debug(msg) self.error = msg @abc.abstractmethod def connection_finished(self): return def is_finished(self, paginated=False): return (self._pagination_exhausted if paginated else self.reply.isFinished())
# coding: utf-8 from PyQt4.QtCore import QUrl from PyQt4.QtNetwork import QNetworkRequest, QSslError from qgis.core import QgsNetworkAccessManager from qgis.gui import QgsAuthSslErrorsDialog url = 'http://fm4dd.com/openssl/source/PEM/certs/1024b-rsa-example-cert.pem' networkAccessManager = QgsNetworkAccessManager.instance() req = QNetworkRequest(QUrl(url)) reply = networkAccessManager.get( req) # Return a QNetworkReply (http://doc.qt.io/qt-4.8/qnetworkreply.html) auth_ssl_errors_dialog = QgsAuthSslErrorsDialog( reply, [QSslError(QSslError.InvalidNotAfterField)]) auth_ssl_errors_dialog.show()
def load_html(self): htmlPath = os.path.dirname(os.path.realpath( __file__)) + '/doc/html/about.html' self.aboutView.load(QUrl(htmlPath))
def urlChanged(self, qUrl): url = qUrl.toString() # Some integrations/auth will get back to /services with no way to get back to chat if Resources.SERVICES_URL_RE.match(url): self.systemOpen(url) self.load(QUrl("https://" + qUrl.host() + "/messages/general"))
def _open_path(path): url = QUrl.fromLocalFile(str(path)) QDesktopServices.openUrl(url)
def loadStarted(self): # Some custom CSS to clean/fix UX self.settings().setUserStyleSheetUrl( QUrl.fromLocalFile(Resources.get_path("resources.css")))
def openOnlineHelp(self): """Opens a link to the Freeseer Online Help""" url = QUrl("http://freeseer.github.io") QDesktopServices.openUrl(url)
def setupUi(self): self.labels = {} self.widgets = {} self.checkBoxes = {} self.showAdvanced = False self.valueItems = {} self.dependentItems = {} self.resize(650, 450) self.buttonBox = QDialogButtonBox() self.buttonBox.setOrientation(Qt.Horizontal) self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) tooltips = self._alg.getParameterDescriptions() self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.verticalLayout = QVBoxLayout() self.verticalLayout.setSpacing(5) self.verticalLayout.setMargin(20) hLayout = QHBoxLayout() hLayout.setSpacing(5) hLayout.setMargin(0) descriptionLabel = QLabel(self.tr("Description")) self.descriptionBox = QLineEdit() self.descriptionBox.setText(self._alg.name) hLayout.addWidget(descriptionLabel) hLayout.addWidget(self.descriptionBox) self.verticalLayout.addLayout(hLayout) line = QFrame() line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) self.verticalLayout.addWidget(line) for param in self._alg.parameters: if param.isAdvanced: self.advancedButton = QPushButton() self.advancedButton.setText( self.tr('Show advanced parameters')) self.advancedButton.setMaximumWidth(150) self.advancedButton.clicked.connect( self.showAdvancedParametersClicked) self.verticalLayout.addWidget(self.advancedButton) break for param in self._alg.parameters: if param.hidden: continue desc = param.description if isinstance(param, ParameterExtent): desc += '(xmin, xmax, ymin, ymax)' label = QLabel(desc) self.labels[param.name] = label widget = self.getWidgetFromParameter(param) self.valueItems[param.name] = widget if param.name in tooltips.keys(): tooltip = tooltips[param.name] else: tooltip = param.description label.setToolTip(tooltip) widget.setToolTip(tooltip) if param.isAdvanced: label.setVisible(self.showAdvanced) widget.setVisible(self.showAdvanced) self.widgets[param.name] = widget self.verticalLayout.addWidget(label) self.verticalLayout.addWidget(widget) for output in self._alg.outputs: if output.hidden: continue if isinstance(output, (OutputRaster, OutputVector, OutputTable, OutputHTML, OutputFile, OutputDirectory)): label = QLabel(output.description + '<' + output.__class__.__name__ + '>') item = QLineEdit() if hasattr(item, 'setPlaceholderText'): item.setPlaceholderText(ModelerParametersDialog.ENTER_NAME) self.verticalLayout.addWidget(label) self.verticalLayout.addWidget(item) self.valueItems[output.name] = item label = QLabel(' ') self.verticalLayout.addWidget(label) label = QLabel(self.tr('Parent algorithms')) self.dependenciesPanel = self.getDependenciesPanel() self.verticalLayout.addWidget(label) self.verticalLayout.addWidget(self.dependenciesPanel) self.verticalLayout.addStretch(1000) self.setLayout(self.verticalLayout) self.setPreviousValues() self.setWindowTitle(self._alg.name) self.verticalLayout2 = QVBoxLayout() self.verticalLayout2.setSpacing(2) self.verticalLayout2.setMargin(0) self.tabWidget = QTabWidget() self.tabWidget.setMinimumWidth(300) self.paramPanel = QWidget() self.paramPanel.setLayout(self.verticalLayout) self.scrollArea = QScrollArea() self.scrollArea.setWidget(self.paramPanel) self.scrollArea.setWidgetResizable(True) self.tabWidget.addTab(self.scrollArea, self.tr('Parameters')) self.webView = QWebView() html = None url = None isText, help = self._alg.help() if help is not None: if isText: html = help else: url = QUrl(help) else: html = self.tr('<h2>Sorry, no help is available for this ' 'algorithm.</h2>') try: if html: self.webView.setHtml(html) elif url: self.webView.load(url) except: self.webView.setHtml( self.tr('<h2>Could not open help file :-( </h2>')) self.tabWidget.addTab(self.webView, 'Help') self.verticalLayout2.addWidget(self.tabWidget) self.verticalLayout2.addWidget(self.buttonBox) self.setLayout(self.verticalLayout2) self.buttonBox.accepted.connect(self.okPressed) self.buttonBox.rejected.connect(self.cancelPressed) QMetaObject.connectSlotsByName(self)
def _showHelp(self): help_path = os.path.join(PagLuxembourg.main.plugin_dir, 'help', 'user', 'index.html') QDesktopServices.openUrl( QUrl('file:///' + help_path, QUrl.TolerantMode))
def qgis_composer_renderer(impact_report, component): """Default Map Report Renderer using QGIS Composer. Render using qgis composer for a given impact_report data and component context. :param impact_report: ImpactReport contains data about the report that is going to be generated. :type impact_report: safe.report.impact_report.ImpactReport :param component: Contains the component metadata and context for rendering the output. :type component: safe.report.report_metadata.QgisComposerComponentsMetadata :return: Whatever type of output the component should be. .. versionadded:: 4.0 """ context = component.context """:type: safe.report.extractors.composer.QGISComposerContext""" qgis_composition_context = impact_report.qgis_composition_context inasafe_context = impact_report.inasafe_context # load composition object composition = QgsComposition(qgis_composition_context.map_settings) # load template main_template_folder = impact_report.metadata.template_folder # we do this condition in case custom template was found if component.template.startswith('../qgis-composer-templates/'): template_path = os.path.join(main_template_folder, component.template) else: template_path = component.template with open(template_path) as template_file: template_content = template_file.read() document = QtXml.QDomDocument() document.setContent(template_content) load_status = composition.loadFromTemplate( document, context.substitution_map) if not load_status: raise TemplateLoadingError( tr('Error loading template: %s') % template_path) # replace image path for img in context.image_elements: item_id = img.get('id') path = img.get('path') image = composition_item(composition, item_id, QgsComposerPicture) """:type: qgis.core.QgsComposerPicture""" if image and path: image.setPicturePath(path) # replace html frame for html_el in context.html_frame_elements: item_id = html_el.get('id') mode = html_el.get('mode') composer_item = composition.getComposerItemById(item_id) try: html_element = composition.getComposerHtmlByItem(composer_item) except: pass """:type: qgis.core.QgsComposerHtml""" if html_element: if mode == 'text': text = html_el.get('text') text = text if text else '' html_element.setContentMode(QgsComposerHtml.ManualHtml) html_element.setHtml(text) html_element.loadHtml() elif mode == 'url': url = html_el.get('url') html_element.setContentMode(QgsComposerHtml.Url) qurl = QUrl.fromLocalFile(url) html_element.setUrl(qurl) original_crs = impact_report.impact_function.impact.crs() destination_crs = qgis_composition_context.map_settings.destinationCrs() coord_transform = QgsCoordinateTransform(original_crs, destination_crs) # resize map extent for map_el in context.map_elements: item_id = map_el.get('id') split_count = map_el.get('grid_split_count') layers = map_el.get('layers') map_extent_option = map_el.get('extent') composer_map = composition_item(composition, item_id, QgsComposerMap) """:type: qgis.core.QgsComposerMap""" if composer_map: composer_map.setKeepLayerSet(True) layer_set = [l.id() for l in layers if isinstance(l, QgsMapLayer)] composer_map.setLayerSet(layer_set) if map_extent_option and isinstance( map_extent_option, QgsRectangle): # use provided map extent extent = coord_transform.transform(map_extent_option) for l in [layer for layer in layers if isinstance(layer, QgsMapLayer)]: layer_extent = coord_transform.transform(l.extent()) if l.name() == map_overview['id']: map_overview_extent = layer_extent else: # if map extent not provided, try to calculate extent # from list of given layers. Combine it so all layers were # shown properly map_overview_extent = None extent = QgsRectangle() extent.setMinimal() for l in [layer for layer in layers if isinstance(layer, QgsMapLayer)]: # combine extent if different layer is provided. layer_extent = coord_transform.transform(l.extent()) extent.combineExtentWith(layer_extent) if l.name() == map_overview['id']: map_overview_extent = layer_extent width = extent.width() height = extent.height() longest_width = width if width > height else height half_length = longest_width / 2 margin = half_length / 5 center = extent.center() min_x = center.x() - half_length - margin max_x = center.x() + half_length + margin min_y = center.y() - half_length - margin max_y = center.y() + half_length + margin # noinspection PyCallingNonCallable square_extent = QgsRectangle(min_x, min_y, max_x, max_y) if component.key == 'population-infographic' and ( map_overview_extent): square_extent = map_overview_extent composer_map.zoomToExtent(square_extent) composer_map.renderModeUpdateCachedImage() actual_extent = composer_map.extent() # calculate intervals for grid x_interval = actual_extent.width() / split_count composer_map.grid().setIntervalX(x_interval) y_interval = actual_extent.height() / split_count composer_map.grid().setIntervalY(y_interval) # calculate legend element for leg_el in context.map_legends: item_id = leg_el.get('id') title = leg_el.get('title') layers = leg_el.get('layers') symbol_count = leg_el.get('symbol_count') column_count = leg_el.get('column_count') legend = composition_item(composition, item_id, QgsComposerLegend) """:type: qgis.core.QgsComposerLegend""" if legend: # set column count if column_count: legend.setColumnCount(column_count) elif symbol_count <= 7: legend.setColumnCount(1) else: legend.setColumnCount(symbol_count / 7 + 1) # set legend title if title is not None: legend.setTitle(title) # set legend root_group = legend.modelV2().rootGroup() for l in layers: # used for customizations tree_layer = root_group.addLayer(l) QgsLegendRenderer.setNodeLegendStyle( tree_layer, QgsComposerLegendStyle.Hidden) legend.synchronizeWithModel() # process to output # in case output folder not specified if impact_report.output_folder is None: impact_report.output_folder = mkdtemp(dir=temp_dir()) output_format = component.output_format component_output_path = impact_report.component_absolute_output_path( component.key) component_output = None doc_format = QgisComposerComponentsMetadata.OutputFormat.DOC_OUTPUT template_format = QgisComposerComponentsMetadata.OutputFormat.QPT if isinstance(output_format, list): component_output = [] for i in range(len(output_format)): each_format = output_format[i] each_path = component_output_path[i] if each_format in doc_format: result_path = create_qgis_pdf_output( impact_report, each_path, composition, each_format, component) component_output.append(result_path) elif each_format == template_format: result_path = create_qgis_template_output( each_path, composition) component_output.append(result_path) elif isinstance(output_format, dict): component_output = {} for key, each_format in output_format.iteritems(): each_path = component_output_path[key] if each_format in doc_format: result_path = create_qgis_pdf_output( impact_report, each_path, composition, each_format, component) component_output[key] = result_path elif each_format == template_format: result_path = create_qgis_template_output( each_path, composition) component_output[key] = result_path elif (output_format in QgisComposerComponentsMetadata.OutputFormat.SUPPORTED_OUTPUT): component_output = None if output_format in doc_format: result_path = create_qgis_pdf_output( impact_report, component_output_path, composition, output_format, component) component_output = result_path elif output_format == template_format: result_path = create_qgis_template_output( component_output_path, composition) component_output = result_path component.output = component_output return component.output
def process_request(self): socket = self.sender() request_data = socket.readAll() if not self.authorize_request(request_data): socket.write('HTTP/1.1 407 Proxy Authentication Required\r\n') if self.debug: self.log.write('407 Proxy Authentication Required\n\n') socket.write('Proxy-Authenticate: Basic realm="test"\r\n') socket.write('\r\n') socket.disconnectFromHost() return else: # remove Proxy-Authorization header start = request_data.indexOf('Proxy-Authorization:') end = request_data.lastIndexOf('\r\n') request_data.remove(start, end) request_data.append('\r\n') pos = request_data.indexOf('\r\n') request_line = request_data.left(pos) request_data.remove(0, pos + 2) entries = request_line.split(' ') method = entries[0] address = entries[1] version = entries[2] port = '80' if address.count(':') > 1: protocol, host, port = address.split(':') else: protocol, host = address.split(':') print 'address', address #url = QUrl( protocol + host ) url = QUrl.fromEncoded(address) #url.setHost( host ) #url.setPort( int(port) ) if not url.isValid(): if self.debug: self.log.write('Invalid URL: %s\n\n', url) socket.disconnectFromHost() return host = url.host() port = 80 if (url.port() < 0) else url.port() req = url.encodedPath() if url.hasQuery(): req.append('?').append(url.encodedQuery()) request_line = method + ' ' + req + ' ' + version + '\r\n' request_data.prepend(request_line) if self.debug: self.log.write(method + ' ' + address + ' ' + version + '\n\n') key = host + ':' + QString.number(port) proxy_socket = socket.findChild(QTcpSocket, key) if proxy_socket: proxy_socket.setObjectName(key) proxy_socket.setProperty('url', url) proxy_socket.setProperty('request_data', request_data) proxy_socket.write(request_data) else: proxy_socket = QTcpSocket(socket) proxy_socket.setObjectName(key) proxy_socket.setProperty('url', url) proxy_socket.setProperty('request_data', request_data) proxy_socket.connected.connect(self.send_request) proxy_socket.readyRead.connect(self.transfer_data) proxy_socket.disconnected.connect(self.close_connection) proxy_socket.error.connect(self.close_connection) proxy_socket.connectToHost(host, port)
def qgis_composer_html_renderer(impact_report, component): """HTML to PDF renderer using QGIS Composer. Render using qgis composer for a given impact_report data and component context for html input. :param impact_report: ImpactReport contains data about the report that is going to be generated. :type impact_report: safe.report.impact_report.ImpactReport :param component: Contains the component metadata and context for rendering the output. :type component: safe.report.report_metadata.QgisComposerComponentsMetadata :return: Whatever type of output the component should be. .. versionadded:: 4.0 """ context = component.context """:type: safe.report.extractors.composer.QGISComposerContext""" qgis_composition_context = impact_report.qgis_composition_context inasafe_context = impact_report.inasafe_context # load composition object composition = QgsComposition(qgis_composition_context.map_settings) if not context.html_frame_elements: # if no html frame elements at all, do not generate empty report. component.output = '' return component.output # Add HTML Frame for html_el in context.html_frame_elements: mode = html_el.get('mode') html_element = QgsComposerHtml(composition, False) """:type: qgis.core.QgsComposerHtml""" margin_left = html_el.get('margin_left', 10) margin_top = html_el.get('margin_top', 10) width = html_el.get('width', component.page_width - 2 * margin_left) height = html_el.get('height', component.page_height - 2 * margin_top) html_frame = QgsComposerFrame( composition, html_element, margin_left, margin_top, width, height) html_element.addFrame(html_frame) if html_element: if mode == 'text': text = html_el.get('text') text = text if text else '' html_element.setContentMode(QgsComposerHtml.ManualHtml) html_element.setResizeMode( QgsComposerHtml.RepeatUntilFinished) html_element.setHtml(text) html_element.loadHtml() elif mode == 'url': url = html_el.get('url') html_element.setContentMode(QgsComposerHtml.Url) html_element.setResizeMode( QgsComposerHtml.RepeatUntilFinished) qurl = QUrl.fromLocalFile(url) html_element.setUrl(qurl) # process to output # in case output folder not specified if impact_report.output_folder is None: impact_report.output_folder = mkdtemp(dir=temp_dir()) component_output_path = impact_report.component_absolute_output_path( component.key) component_output = None output_format = component.output_format doc_format = QgisComposerComponentsMetadata.OutputFormat.DOC_OUTPUT template_format = QgisComposerComponentsMetadata.OutputFormat.QPT if isinstance(output_format, list): component_output = [] for i in range(len(output_format)): each_format = output_format[i] each_path = component_output_path[i] if each_format in doc_format: result_path = create_qgis_pdf_output( impact_report, each_path, composition, each_format, component) component_output.append(result_path) elif each_format == template_format: result_path = create_qgis_template_output( each_path, composition) component_output.append(result_path) elif isinstance(output_format, dict): component_output = {} for key, each_format in output_format.iteritems(): each_path = component_output_path[key] if each_format in doc_format: result_path = create_qgis_pdf_output( impact_report, each_path, composition, each_format, component) component_output[key] = result_path elif each_format == template_format: result_path = create_qgis_template_output( each_path, composition) component_output[key] = result_path elif (output_format in QgisComposerComponentsMetadata.OutputFormat.SUPPORTED_OUTPUT): component_output = None if output_format in doc_format: result_path = create_qgis_pdf_output( impact_report, component_output_path, composition, output_format, component) component_output = result_path elif output_format == template_format: result_path = create_qgis_template_output( component_output_path, composition) component_output = result_path component.output = component_output return component.output
def __init__(self, url): self.app = QApplication(sys.argv) QWebPage.__init__(self) self.loadFinished.connect(self._loadFinished) self.mainFrame().load(QUrl(url)) self.app.exec_()
def drop_request(request): """ Drop the request """ # hack: set invalid URL request.setUrl(QUrl(''))