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 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 + '"'
