def exportVectorLayerFromParameter(self, name, parameters, context, layer=None, nocats=False): """ Creates a dedicated command to export a vector from a QgsProcessingParameter. :param name: name of the parameter. :param context: parameters context. :param layer: for vector with multiples layers, exports only one layer. :param nocats: do not export GRASS categories. """ fileName = os.path.normpath( self.parameterAsOutputLayer(parameters, name, context)) grassName = '{}{}'.format(name, self.uniqueSuffix) # Find if there is a dataType dataType = self.outType if self.outType == 'auto': parameter = self.parameterDefinition(name) if parameter: layerType = parameter.dataType() if layerType in self.QGIS_OUTPUT_TYPES: dataType = self.QGIS_OUTPUT_TYPES[layerType] outFormat = QgsVectorFileWriter.driverForExtension(os.path.splitext(fileName)[1]).replace(' ', '_') dsco = self.parameterAsString(parameters, self.GRASS_VECTOR_DSCO, context) lco = self.parameterAsString(parameters, self.GRASS_VECTOR_LCO, context) exportnocat = self.parameterAsBool(parameters, self.GRASS_VECTOR_EXPORT_NOCAT, context) self.exportVectorLayer(grassName, fileName, layer, nocats, dataType, outFormat, dsco, lco, exportnocat)
def exportVectorLayer(self, grassName, fileName, layer=None, nocats=False, dataType='auto', outFormat=None, dsco=None, lco=None, exportnocat=False): """ Creates a dedicated command to export a vector from temporary GRASS DB into a file via OGR. :param grassName: name of the vector to export. :param fileName: file path of vector layer. :param dataType: export only this type of data. :param layer: for vector with multiples layers, exports only one layer. :param nocats: do not export GRASS categories. :param outFormat: file format for export. :param dsco: datasource creation options for format. :param lco: layer creation options for format. :param exportnocat: do not export features without categories. """ if outFormat is None: outFormat = QgsVectorFileWriter.driverForExtension(os.path.splitext(fileName)[1]).replace(' ', '_') for cmd in [self.commands, self.outputCommands]: cmd.append( 'v.out.ogr{0} type="{1}" input="{2}" output="{3}" format="{4}" {5}{6}{7}{8} --overwrite'.format( '' if nocats else '', dataType, grassName, fileName, outFormat, 'layer={}'.format(layer) if layer else '', ' dsco="{}"'.format(dsco) if dsco else '', ' lco="{}"'.format(lco) if lco else '', ' -c' if exportnocat else '' ) )
def testDriverForExtension(self): self.assertEqual(QgsVectorFileWriter.driverForExtension('shp'), 'ESRI Shapefile') self.assertEqual(QgsVectorFileWriter.driverForExtension('SHP'), 'ESRI Shapefile') self.assertEqual(QgsVectorFileWriter.driverForExtension('sHp'), 'ESRI Shapefile') self.assertEqual(QgsVectorFileWriter.driverForExtension('.shp'), 'ESRI Shapefile') self.assertEqual(QgsVectorFileWriter.driverForExtension('tab'), 'MapInfo File') self.assertEqual(QgsVectorFileWriter.driverForExtension('.GML'), 'GML') self.assertEqual(QgsVectorFileWriter.driverForExtension('not a format'), '') self.assertEqual(QgsVectorFileWriter.driverForExtension(''), '')
def build_export_commands(self, parameters, context, _): """ Builds up the set of R commands for exporting results """ commands = [] for out in self.destinationParameterDefinitions(): if isinstance(out, QgsProcessingParameterRasterDestination): dest = self.parameterAsOutputLayer(parameters, out.name(), context) dest = dest.replace('\\', '/') commands.append( self.r_templates.write_raster_output(out.name(), dest)) self.results[out.name()] = dest elif isinstance(out, QgsProcessingParameterVectorDestination): dest = self.parameterAsOutputLayer(parameters, out.name(), context) dest = dest.replace('\\', '/') filename = os.path.basename(dest) filename, ext = os.path.splitext(filename) if ext.lower() == '.csv': # CSV table export commands.append( self.r_templates.write_csv_output(out.name(), dest)) else: commands.append( self.r_templates.write_vector_output( out.name(), dest, filename, QgsVectorFileWriter.driverForExtension(ext))) self.results[out.name()] = dest if self.save_output_values: for out in self.outputDefinitions(): name = out.name() # write values only if output is not already in results if name in (self.R_CONSOLE_OUTPUT, self.RPLOTS): continue if name in self.results: continue # create file path for output values only if it is necessary if not self.output_values_filename: self.output_values_filename = QgsProcessingUtils.generateTempFilename( 'processing_values.txt') # write output name and value with cat commands.extend( self.r_templates.write_cat_output( name, self.output_values_filename)) if self.show_plots: commands.append(self.r_templates.dev_off()) return commands
def testDriverForExtension(self): self.assertEqual(QgsVectorFileWriter.driverForExtension('shp'), 'ESRI Shapefile') self.assertEqual(QgsVectorFileWriter.driverForExtension('SHP'), 'ESRI Shapefile') self.assertEqual(QgsVectorFileWriter.driverForExtension('sHp'), 'ESRI Shapefile') self.assertEqual(QgsVectorFileWriter.driverForExtension('.shp'), 'ESRI Shapefile') self.assertEqual(QgsVectorFileWriter.driverForExtension('tab'), 'MapInfo File') self.assertEqual(QgsVectorFileWriter.driverForExtension('.GML'), 'GML') self.assertEqual( QgsVectorFileWriter.driverForExtension('not a format'), '') self.assertEqual(QgsVectorFileWriter.driverForExtension(''), '')
def ogrConnectionStringAndFormat(uri, context): """Generates OGR connection string and format string from layer source Returned values are a tuple of the connection string and format string """ ogrstr = None format = None layer = QgsProcessingUtils.mapLayerFromString(uri, context, False) if layer is None: path, ext = os.path.splitext(uri) format = QgsVectorFileWriter.driverForExtension(ext) return uri, '"' + format + '"' return GdalUtils.ogrConnectionStringAndFormatFromLayer(layer)
def save_as_gml(layer, path): transform_context = QgsProject.instance().transformContext() save_options = QgsVectorFileWriter.SaveVectorOptions() save_options.driverName = QgsVectorFileWriter.driverForExtension("gml") save_options.fileEncoding = "UTF-8" QgsVectorFileWriter.writeAsVectorFormatV2( layer, path, transform_context, save_options, ) output = QgsVectorLayer(path, "output", "ogr") assert output.isValid() return output
def export_as_xlsx(context, file_path, input_layer) -> None: """ Export the layer to XLSX to the given path. """ options = QgsVectorFileWriter.SaveVectorOptions() options.driverName = QgsVectorFileWriter.driverForExtension('xlsx') options.fileEncoding = 'UTF-8' options.layerName = input_layer.name() options.layerOptions = ['OGR_XLSX_FIELD_TYPES=AUTO'] write_result, error_message = QgsVectorFileWriter.writeAsVectorFormatV2( input_layer, file_path, context.project().transformContext(), options, ) if write_result != QgsVectorFileWriter.NoError: raise QgsProcessingException(error_message)
def generateCommand(self, parameters, context, feedback): layer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if layer is None: raise QgsProcessingException( self.invalidRasterError(parameters, self.INPUT)) samples = self.parameterAsRasterLayer(parameters, self.SAMPLES, context) if samples is None: raise QgsProcessingException( self.invalidRasterError(parameters, self.SAMPLES)) output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments = [] arguments.append(self.commandName()) arguments.append('-i') arguments.append(layer.source()) arguments.append('-s') arguments.append(samples.source()) if self.THRESHOLD in parameters and parameters[ self.THRESHOLD] is not None: arguments.append('-t') arguments.append('{}'.format( self.parameterAsDouble(parameters, self.THRESHOLD, context))) if self.CLASSES in parameters and parameters[self.CLASSES] is not None: classes = self.parameterAsString(parameters, self.CLASSES, context) arguments.extend(pktoolsUtils.parseCompositeOption('-c', classes)) if self.ARGUMENTS in parameters and parameters[ self.ARGUMENTS] is not None: args = self.parameterAsString(parameters, self.ARGUMENTS, context).split(' ') if args: arguments.extend(args) arguments.append('-f') arguments.append( QgsVectorFileWriter.driverForExtension( os.path.splitext(output)[1])) arguments.append('-o') arguments.append(output) return arguments
def skipOutputChanged(widget, checkbox, skipped): enabled = not skipped # Do not try to open formats that are write-only. value = widget.value() if value and isinstance(value, QgsProcessingOutputLayerDefinition) and isinstance(output, ( QgsProcessingParameterFeatureSink, QgsProcessingParameterVectorDestination)): filename = value.sink.staticValue() if filename not in ('memory:', ''): path, ext = os.path.splitext(filename) format = QgsVectorFileWriter.driverForExtension(ext) drv = gdal.GetDriverByName(format) if drv: if drv.GetMetadataItem(gdal.DCAP_OPEN) is None: enabled = False checkbox.setEnabled(enabled) checkbox.setChecked(enabled)
def generateCommand(self, parameters, context, feedback): crs = self.parameterAsCrs(parameters, self.CRS, context) output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments = [] arguments.append(self.commandName()) arguments.append('-i') arguments.append(self.parameterAsFile(parameters, self.INPUT, context)) arguments.append('-x') arguments.append('{}'.format( self.parameterAsInt(parameters, self.COLUMN_X, context))) arguments.append('-y') arguments.append('{}'.format( self.parameterAsInt(parameters, self.COLUMN_Y, context))) arguments.append('-a_srs') arguments.append(crs.authid()) if self.FIELDS in parameters and parameters[self.FIELDS] is not None: fields = self.parameterAsString(parameters, self.FIELDS, context).split(' ') if fields: arguments.extend(fields) if self.SEPARATOR in parameters and parameters[ self.SEPARATOR] is not None: sep = self.parameterAsString(parameters, self.SEPARATOR, context) if sep: arguments.append('-fs') arguments.append(sep) if self.parameterAsBoolean(parameters, self.CREATE_POLYGON, context): arguments.append('-l') arguments.append('-f') arguments.append( QgsVectorFileWriter.driverForExtension( os.path.splitext(output)[1])) arguments.append('-o') arguments.append(output) return arguments
def build_export_commands(self, parameters, context, _): """ Builds up the set of R commands for exporting results """ commands = [] for out in self.destinationParameterDefinitions(): if isinstance(out, QgsProcessingParameterRasterDestination): dest = self.parameterAsOutputLayer(parameters, out.name(), context) dest = dest.replace('\\', '/') if self.use_raster_package or self.pass_file_names: commands.append( 'writeRaster({},"{}", overwrite=TRUE)'.format( out.name(), dest)) else: if not dest.lower().endswith('tif'): dest = dest + '.tif' commands.append('writeGDAL({},"{}")'.format( out.name(), dest)) self.results[out.name()] = dest elif isinstance(out, QgsProcessingParameterVectorDestination): dest = self.parameterAsOutputLayer(parameters, out.name(), context) dest = dest.replace('\\', '/') filename = os.path.basename(dest) filename, ext = os.path.splitext(filename) if ext.lower() == '.csv': # CSV table export commands.append('write.csv(' + out.name() + ',"' + dest + '")') else: commands.append( 'writeOGR(' + out.name() + ',"' + dest + '","' + filename + '", driver="{}")'.format( QgsVectorFileWriter.driverForExtension(ext))) self.results[out.name()] = dest if self.show_plots: commands.append('dev.off()') return commands
def generateCommand(self, parameters, context, feedback): layer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if layer is None: raise QgsProcessingException( self.invalidRasterError(parameters, self.INPUT)) output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments = [] arguments.append(self.commandName()) arguments.append('-i') arguments.append(layer.source()) arguments.append('-b') arguments.append('{}'.format( self.parameterAsInt(parameters, self.BAND, context) - 1)) if self.MASK in parameters and parameters[self.MASK] is not None: mask = self.parameterAsRasterLayer(parameters, self.MASK, context) if mask: arguments.append('-m') arguments.append(mask.source()) arguments.append('-n') arguments.append( self.parameterAsString(parameters, self.FIELD_NAME, context)) if self.NODATA in parameters and parameters[self.NODATA] is not None: arguments.append('-nodata') arguments.append('{}'.format( self.parameterAsDouble(parameters, self.NODATA, context))) arguments.append('-f') arguments.append( QgsVectorFileWriter.driverForExtension( os.path.splitext(output)[1])) arguments.append('-o') arguments.append(output) return arguments
def exportVectorLayerFromParameter(self, name, parameters, context, layer=None, nocats=False): """ Creates a dedicated command to export a vector from a QgsProcessingParameter. :param name: name of the parameter. :param context: parameters context. :param layer: for vector with multiples layers, exports only one layer. :param nocats: do not export GRASS categories. """ fileName = os.path.normpath( self.parameterAsOutputLayer(parameters, name, context)) grassName = '{}{}'.format(name, self.uniqueSuffix) # Find if there is a dataType dataType = self.outType if self.outType == 'auto': parameter = self.parameterDefinition(name) if parameter: layerType = parameter.dataType() if layerType in self.QGIS_OUTPUT_TYPES: dataType = self.QGIS_OUTPUT_TYPES[layerType] outFormat = QgsVectorFileWriter.driverForExtension( os.path.splitext(fileName)[1]).replace(' ', '_') dsco = self.parameterAsString(parameters, self.GRASS_VECTOR_DSCO, context) lco = self.parameterAsString(parameters, self.GRASS_VECTOR_LCO, context) exportnocat = self.parameterAsBool(parameters, self.GRASS_VECTOR_EXPORT_NOCAT, context) self.exportVectorLayer(grassName, fileName, layer, nocats, dataType, outFormat, dsco, lco, exportnocat)
def ogrConnectionStringAndFormatFromLayer(layer): provider = layer.dataProvider().name() if provider == 'spatialite': # dbname='/geodata/osm_ch.sqlite' table="places" (Geometry) sql= regex = re.compile("dbname='(.+)'") r = regex.search(str(layer.source())) ogrstr = r.groups()[0] format = 'SQLite' elif provider == 'postgres': # dbname='ktryjh_iuuqef' host=spacialdb.com port=9999 # user='******' password='******' sslmode=disable # key='gid' estimatedmetadata=true srid=4326 type=MULTIPOLYGON # table="t4" (geom) sql= dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) conninfo = dsUri.connectionInfo() conn = None ok = False while not conn: try: conn = psycopg2.connect(dsUri.connectionInfo()) except psycopg2.OperationalError: (ok, user, passwd) = QgsCredentials.instance().get(conninfo, dsUri.username(), dsUri.password()) if not ok: break dsUri.setUsername(user) dsUri.setPassword(passwd) if not conn: raise RuntimeError('Could not connect to PostgreSQL database - check connection info') if ok: QgsCredentials.instance().put(conninfo, user, passwd) ogrstr = "PG:%s" % dsUri.connectionInfo() format = 'PostgreSQL' elif provider == 'mssql': #'dbname=\'db_name\' host=myHost estimatedmetadata=true # srid=27700 type=MultiPolygon table="dbo"."my_table" # #(Shape) sql=' dsUri = layer.dataProvider().uri() ogrstr = 'MSSQL:' ogrstr += 'database={0};'.format(dsUri.database()) ogrstr += 'server={0};'.format(dsUri.host()) if dsUri.username() != "": ogrstr += 'uid={0};'.format(dsUri.username()) else: ogrstr += 'trusted_connection=yes;' if dsUri.password() != '': ogrstr += 'pwd={0};'.format(dsUri.password()) ogrstr += 'tables={0}'.format(dsUri.table()) format = 'MSSQL' elif provider == "oracle": # OCI:user/password@host:port/service:table dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) ogrstr = "OCI:" if dsUri.username() != "": ogrstr += dsUri.username() if dsUri.password() != "": ogrstr += "/" + dsUri.password() delim = "@" if dsUri.host() != "": ogrstr += delim + dsUri.host() delim = "" if dsUri.port() != "" and dsUri.port() != '1521': ogrstr += ":" + dsUri.port() ogrstr += "/" if dsUri.database() != "": ogrstr += dsUri.database() elif dsUri.database() != "": ogrstr += delim + dsUri.database() if ogrstr == "OCI:": raise RuntimeError('Invalid oracle data source - check connection info') ogrstr += ":" if dsUri.schema() != "": ogrstr += dsUri.schema() + "." ogrstr += dsUri.table() format = 'OCI' else: ogrstr = str(layer.source()).split("|")[0] path, ext = os.path.splitext(ogrstr) format = QgsVectorFileWriter.driverForExtension(ext) return ogrstr, '"' + format + '"'
def create_geopackage(project_type: ProjectType, file_path, crs, transform_context) -> None: """ Create the geopackage for the given path. """ encoding = 'UTF-8' driver_name = QgsVectorFileWriter.driverForExtension('gpkg') for table in project_type.layers: layer_path = str(tables[table]) if layer_path != 'None': layer_path += "?crs={}".format(crs.authid()) vector_layer = QgsVectorLayer(layer_path, table, "memory") data_provider = vector_layer.dataProvider() fields = QgsFields() path = resources_path('data_models', '{}.csv'.format(table)) csv = load_csv(table, path) for csv_feature in csv.getFeatures(): field = QgsField(name=csv_feature['name'], type=int(csv_feature['type'])) field.setComment(csv_feature['comment']) field.setAlias(csv_feature['alias']) fields.append(field) del csv # add fields data_provider.addAttributes(fields) vector_layer.updateFields() # set create file layer options options = QgsVectorFileWriter.SaveVectorOptions() options.driverName = driver_name options.fileEncoding = encoding options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteFile if os.path.exists(file_path): options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteLayer options.layerName = vector_layer.name() options.layerOptions = ['FID=id'] # write file if Qgis.QGIS_VERSION_INT >= 31900: write_result, error_message, _, _ = QgsVectorFileWriter.writeAsVectorFormatV3( vector_layer, file_path, transform_context, options) else: # 3.10 <= QGIS <3.18 write_result, error_message = QgsVectorFileWriter.writeAsVectorFormatV2( vector_layer, file_path, transform_context, options) # result if write_result != QgsVectorFileWriter.NoError: raise QgsProcessingException( '* ERROR: {}'.format(error_message)) del fields del data_provider del vector_layer
def processAlgorithm(self, parameters, context, feedback): """ Here is where the processing itself takes place. """ source = self.parameterAsSource(parameters, self.INPUT, context) path = self.parameterAsFile(parameters, self.OUTPUT, context) field_def = { 'idx': QVariant.Int, 'name': QVariant.String, 'type': QVariant.Int, 'typeName': QVariant.String, 'length': QVariant.Int, 'precision': QVariant.Int, 'comment': QVariant.String, 'alias': QVariant.String } # create virtual layer vl = QgsVectorLayer("None", "fields", "memory") pr = vl.dataProvider() # define fields fields = QgsFields() for n, t in field_def.items(): fields.append(QgsField(name=n, type=t)) # add fields pr.addAttributes(fields) vl.updateFields( ) # tell the vector layer to fetch changes from the provider # add feature based on field description field_index = 0 for f in providerFields(source.fields()): field_index += 1 feat = QgsFeature() feat.setAttributes([ field_index, f.name(), f.type(), f.typeName(), f.length(), f.precision(), f.comment(), f.alias() ]) pr.addFeatures([feat]) # set create file layer options options = QgsVectorFileWriter.SaveVectorOptions() options.driverName = QgsVectorFileWriter.driverForExtension('csv') options.fileEncoding = 'UTF-8' options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteFile options.layerOptions = ['CREATE_CSVT=YES'] # write file write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat( vl, path, options) # result if write_result != QgsVectorFileWriter.NoError: raise QgsProcessingException( self.tr('* ERROR: {0}').format(error_message)) del fields del pr del vl # create layer dest_layer = QgsVectorLayer(path, self.OUTPUT_LAYER, 'ogr') if not dest_layer.isValid(): raise QgsProcessingException( self.tr('* ERROR: Can\'t load layer {1} in {0}').format( path, self.OUTPUT_LAYER)) # Add layer to context context.temporaryLayerStore().addMapLayer(dest_layer) context.addLayerToLoadOnCompletion( dest_layer.id(), QgsProcessingContext.LayerDetails(self.OUTPUT_LAYER, context.project(), self.OUTPUT_LAYER)) return {self.OUTPUT: path, self.OUTPUT_LAYER: dest_layer.id()}
def ogrConnectionStringAndFormat(uri, context): """Generates OGR connection string and format string from layer source Returned values are a tuple of the connection string and format string """ ogrstr = None format = None layer = QgsProcessingUtils.mapLayerFromString(uri, context, False) if layer is None: path, ext = os.path.splitext(uri) format = QgsVectorFileWriter.driverForExtension(ext) return uri, '"' + format + '"' provider = layer.dataProvider().name() if provider == 'spatialite': # dbname='/geodata/osm_ch.sqlite' table="places" (Geometry) sql= regex = re.compile("dbname='(.+)'") r = regex.search(str(layer.source())) ogrstr = r.groups()[0] format = 'SQLite' elif provider == 'postgres': # dbname='ktryjh_iuuqef' host=spacialdb.com port=9999 # user='******' password='******' sslmode=disable # key='gid' estimatedmetadata=true srid=4326 type=MULTIPOLYGON # table="t4" (geom) sql= dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) conninfo = dsUri.connectionInfo() conn = None ok = False while not conn: try: conn = psycopg2.connect(dsUri.connectionInfo()) except psycopg2.OperationalError: (ok, user, passwd) = QgsCredentials.instance().get(conninfo, dsUri.username(), dsUri.password()) if not ok: break dsUri.setUsername(user) dsUri.setPassword(passwd) if not conn: raise RuntimeError('Could not connect to PostgreSQL database - check connection info') if ok: QgsCredentials.instance().put(conninfo, user, passwd) ogrstr = "PG:%s" % dsUri.connectionInfo() format = 'PostgreSQL' elif provider == "oracle": # OCI:user/password@host:port/service:table dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) ogrstr = "OCI:" if dsUri.username() != "": ogrstr += dsUri.username() if dsUri.password() != "": ogrstr += "/" + dsUri.password() delim = "@" if dsUri.host() != "": ogrstr += delim + dsUri.host() delim = "" if dsUri.port() != "" and dsUri.port() != '1521': ogrstr += ":" + dsUri.port() ogrstr += "/" if dsUri.database() != "": ogrstr += dsUri.database() elif dsUri.database() != "": ogrstr += delim + dsUri.database() if ogrstr == "OCI:": raise RuntimeError('Invalid oracle data source - check connection info') ogrstr += ":" if dsUri.schema() != "": ogrstr += dsUri.schema() + "." ogrstr += dsUri.table() format = 'OCI' else: ogrstr = str(layer.source()).split("|")[0] path, ext = os.path.splitext(ogrstr) format = QgsVectorFileWriter.driverForExtension(ext) return ogrstr, '"' + format + '"'
def ogrConnectionStringAndFormatFromLayer(layer): provider = layer.dataProvider().name() if provider == 'spatialite': # dbname='/geodata/osm_ch.sqlite' table="places" (Geometry) sql= regex = re.compile("dbname='(.+)'") r = regex.search(str(layer.source())) ogrstr = r.groups()[0] format = 'SQLite' elif provider == 'postgres': # dbname='ktryjh_iuuqef' host=spacialdb.com port=9999 # user='******' password='******' sslmode=disable # key='gid' estimatedmetadata=true srid=4326 type=MULTIPOLYGON # table="t4" (geom) sql= dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) conninfo = dsUri.connectionInfo() conn = None ok = False while not conn: try: conn = psycopg2.connect(dsUri.connectionInfo()) except psycopg2.OperationalError: (ok, user, passwd) = QgsCredentials.instance().get( conninfo, dsUri.username(), dsUri.password()) if not ok: break dsUri.setUsername(user) dsUri.setPassword(passwd) if not conn: raise RuntimeError( 'Could not connect to PostgreSQL database - check connection info' ) if ok: QgsCredentials.instance().put(conninfo, user, passwd) ogrstr = "PG:%s" % dsUri.connectionInfo() format = 'PostgreSQL' elif provider == 'mssql': #'dbname=\'db_name\' host=myHost estimatedmetadata=true # srid=27700 type=MultiPolygon table="dbo"."my_table" # #(Shape) sql=' dsUri = layer.dataProvider().uri() ogrstr = 'MSSQL:' ogrstr += 'database={0};'.format(dsUri.database()) ogrstr += 'server={0};'.format(dsUri.host()) if dsUri.username() != "": ogrstr += 'uid={0};'.format(dsUri.username()) else: ogrstr += 'trusted_connection=yes;' if dsUri.password() != '': ogrstr += 'pwd={0};'.format(dsUri.password()) ogrstr += 'tables={0}'.format(dsUri.table()) format = 'MSSQL' elif provider == "oracle": # OCI:user/password@host:port/service:table dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) ogrstr = "OCI:" if dsUri.username() != "": ogrstr += dsUri.username() if dsUri.password() != "": ogrstr += "/" + dsUri.password() delim = "@" if dsUri.host() != "": ogrstr += delim + dsUri.host() delim = "" if dsUri.port() != "" and dsUri.port() != '1521': ogrstr += ":" + dsUri.port() ogrstr += "/" if dsUri.database() != "": ogrstr += dsUri.database() elif dsUri.database() != "": ogrstr += delim + dsUri.database() if ogrstr == "OCI:": raise RuntimeError( 'Invalid oracle data source - check connection info') ogrstr += ":" if dsUri.schema() != "": ogrstr += dsUri.schema() + "." ogrstr += dsUri.table() format = 'OCI' else: ogrstr = str(layer.source()).split("|")[0] path, ext = os.path.splitext(ogrstr) format = QgsVectorFileWriter.driverForExtension(ext) return ogrstr, '"' + format + '"'
def generateCommand(self, parameters, context, feedback): layer = self.parameterAsRasterLayer(parameters, self.INPUT, context) if layer is None: raise QgsProcessingException( self.invalidRasterError(parameters, self.INPUT)) rule = self.rules[self.parameterAsEnum(parameters, self.RULE, context)][1] if rule in ('mode', 'proportion', 'count') and (self.CLASSES not in parameters or parameters[self.CLASSES] is None): raise QgsProcessingException( self. tr('Please specify classes to extract or choose another extraction rule.' )) if rule == 'percentile' and (self.PERCENTILE not in parameters or parameters[self.PERCENTILE] is None): raise QgsProcessingException( self. tr('Please specify percentile or choose another extraction rule.' )) output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context) arguments = [] arguments.append(self.commandName()) arguments.append('-i') arguments.append(layer.source()) arguments.append('-rand') arguments.append('{}'.format( self.parameterAsInt(parameters, self.COUNT, context))) arguments.append('-buf') arguments.append('{}'.format( self.parameterAsInt(parameters, self.BUFFER, context))) arguments.append('-r') arguments.append(rule) if rule in ('mode', 'proportion', 'count'): classes = self.parameterAsString(parameters, self.CLASSES, context) arguments.extend(pktoolsUtils.parseCompositeOption('-c', classes)) if rule == 'percentile': arguments.append('-perc') arguments.append('{}'.format( self.parameterAsDouble(parameters, self.PERCENTILE, context))) if self.THRESHOLD in parameters and parameters[ self.THRESHOLD] is not None: arguments.append('-t') arguments.append('{}'.format( self.parameterAsDouble(parameters, self.THRESHOLD, context))) if self.ARGUMENTS in parameters and parameters[ self.ARGUMENTS] is not None: args = self.parameterAsString(parameters, self.ARGUMENTS, context).split(' ') if args: arguments.extend(args) arguments.append('-f') arguments.append( QgsVectorFileWriter.driverForExtension( os.path.splitext(output)[1])) arguments.append('-o') arguments.append(output) return arguments
def ogrConnectionStringAndFormat(uri, context): """Generates OGR connection string and format string from layer source Returned values are a tuple of the connection string and format string """ ogrstr = None format = None layer = QgsProcessingUtils.mapLayerFromString(uri, context, False) if layer is None: path, ext = os.path.splitext(uri) format = QgsVectorFileWriter.driverForExtension(ext) return '"' + uri + '"', '"' + format + '"' provider = layer.dataProvider().name() if provider == 'spatialite': # dbname='/geodata/osm_ch.sqlite' table="places" (Geometry) sql= regex = re.compile("dbname='(.+)'") r = regex.search(str(layer.source())) ogrstr = r.groups()[0] format = 'SQLite' elif provider == 'postgres': # dbname='ktryjh_iuuqef' host=spacialdb.com port=9999 # user='******' password='******' sslmode=disable # key='gid' estimatedmetadata=true srid=4326 type=MULTIPOLYGON # table="t4" (geom) sql= dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) conninfo = dsUri.connectionInfo() conn = None ok = False while not conn: try: conn = psycopg2.connect(dsUri.connectionInfo()) except psycopg2.OperationalError: (ok, user, passwd) = QgsCredentials.instance().get(conninfo, dsUri.username(), dsUri.password()) if not ok: break dsUri.setUsername(user) dsUri.setPassword(passwd) if not conn: raise RuntimeError('Could not connect to PostgreSQL database - check connection info') if ok: QgsCredentials.instance().put(conninfo, user, passwd) ogrstr = "PG:%s" % dsUri.connectionInfo() format = 'PostgreSQL' elif provider == "oracle": # OCI:user/password@host:port/service:table dsUri = QgsDataSourceUri(layer.dataProvider().dataSourceUri()) ogrstr = "OCI:" if dsUri.username() != "": ogrstr += dsUri.username() if dsUri.password() != "": ogrstr += "/" + dsUri.password() delim = "@" if dsUri.host() != "": ogrstr += delim + dsUri.host() delim = "" if dsUri.port() != "" and dsUri.port() != '1521': ogrstr += ":" + dsUri.port() ogrstr += "/" if dsUri.database() != "": ogrstr += dsUri.database() elif dsUri.database() != "": ogrstr += delim + dsUri.database() if ogrstr == "OCI:": raise RuntimeError('Invalid oracle data source - check connection info') ogrstr += ":" if dsUri.schema() != "": ogrstr += dsUri.schema() + "." ogrstr += dsUri.table() format = 'OCI' else: ogrstr = str(layer.source()).split("|")[0] path, ext = os.path.splitext(ogrstr) format = QgsVectorFileWriter.driverForExtension(ext) return '"' + ogrstr + '"', '"' + format + '"'