def setup_translation(
file_pattern: str = "{}.qm",
folder: Optional[str] = None) -> Tuple[str, Optional[str]]:
"""Find the translation file according to locale.
:param file_pattern: Custom file pattern to use to find QM files.
:type file_pattern: basestring
:param folder: Optional folder to look in if it's not the default.
:type folder: basestring
:return: The locale and the file path to the QM file, or None.
:rtype: (basestring, basestring)
"""
locale = QgsSettings().value("locale/userLocale", QLocale().name())
for prefix in ['', f'{plugin_name()}_', f'{slug_name()}_']:
for fldr in [folder, plugin_path('i18n'), resources_path("i18n")]:
prefixed_locale = prefix + locale
if fldr:
ts_file = QFileInfo(
join(fldr, file_pattern.format(prefixed_locale)))
if ts_file.exists():
return locale, ts_file.absoluteFilePath()
prefixed_locale = prefix + locale[0:2]
if fldr:
ts_file = QFileInfo(
join(fldr, file_pattern.format(prefixed_locale)))
if ts_file.exists():
return locale, ts_file.absoluteFilePath()
return locale, None
def setup_translation(file_pattern="{}.qm", folder=None):
"""Find the translation file according to locale.
:param file_pattern: Custom file pattern to use to find QM files.
:type file_pattern: basestring
:param folder: Optional folder to look in if it's not the default.
:type folder: basestring
:return: The locale and the file path to the QM file, or None.
:rtype: (basestring, basestring)
"""
locale = QgsSettings().value("locale/userLocale", QLocale().name())
if folder:
ts_file = QFileInfo(join(folder, file_pattern.format(locale)))
else:
ts_file = QFileInfo(resources_path("i18n", file_pattern.format(locale)))
if ts_file.exists():
return locale, ts_file.absoluteFilePath()
if folder:
ts_file = QFileInfo(join(folder, file_pattern.format(locale[0:2])))
else:
ts_file = QFileInfo(resources_path("i18n", file_pattern.format(locale[0:2])))
if ts_file.exists():
return locale, ts_file.absoluteFilePath()
return locale, None
def _add_tabular_layer(self, tabular_layer, layer_name, save_style=False):
"""Add a tabular layer to the folder.
:param tabular_layer: The layer to add.
:type tabular_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:param save_style: If we have to save a QML too. Default to False.
:type save_style: bool
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
output = QFileInfo(
self.uri.filePath(layer_name + '.csv'))
QgsVectorFileWriter.writeAsVectorFormat(
tabular_layer,
output.absoluteFilePath(),
'utf-8',
QgsCoordinateTransform(),
'CSV')
if save_style:
style_path = QFileInfo(self.uri.filePath(layer_name + '.qml'))
tabular_layer.saveNamedStyle(style_path.absoluteFilePath())
assert output.exists()
return True, output.baseName()
def _add_tabular_layer(self, tabular_layer, layer_name, save_style=False):
"""Add a tabular layer to the folder.
:param tabular_layer: The layer to add.
:type tabular_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:param save_style: If we have to save a QML too. Default to False.
:type save_style: bool
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
output = QFileInfo(self.uri.filePath(layer_name + '.csv'))
QgsVectorFileWriter.writeAsVectorFormat(tabular_layer,
output.absoluteFilePath(),
'utf-8',
QgsCoordinateTransform(),
'CSV')
if save_style:
style_path = QFileInfo(self.uri.filePath(layer_name + '.qml'))
tabular_layer.saveNamedStyle(style_path.absoluteFilePath())
assert output.exists()
return True, output.baseName()
def _add_raster_layer(self, raster_layer, layer_name, save_style=False):
"""Add a raster layer to the folder.
:param raster_layer: The layer to add.
:type raster_layer: QgsRasterLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:param save_style: If we have to save a QML too. Default to False.
:type save_style: bool
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if not self.is_writable():
return False, 'The destination is not writable.'
output = QFileInfo(self.uri.filePath(layer_name + '.tif'))
source = QFileInfo(raster_layer.source())
if source.exists() and source.suffix() in ['tiff', 'tif']:
# If it's tiff file based.
QFile.copy(source.absoluteFilePath(), output.absoluteFilePath())
else:
# If it's not file based.
renderer = raster_layer.renderer()
provider = raster_layer.dataProvider()
crs = raster_layer.crs()
pipe = QgsRasterPipe()
pipe.set(provider.clone())
pipe.set(renderer.clone())
file_writer = QgsRasterFileWriter(output.absoluteFilePath())
file_writer.Mode(1)
file_writer.writeRaster(
pipe,
provider.xSize(),
provider.ySize(),
provider.extent(),
crs)
del file_writer
if save_style:
style_path = QFileInfo(self.uri.filePath(layer_name + '.qml'))
raster_layer.saveNamedStyle(style_path.absoluteFilePath())
assert output.exists()
return True, output.baseName()
def _add_raster_layer(self, raster_layer, layer_name, save_style=False):
"""Add a raster layer to the folder.
:param raster_layer: The layer to add.
:type raster_layer: QgsRasterLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:param save_style: If we have to save a QML too. Default to False.
:type save_style: bool
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if not self.is_writable():
return False, 'The destination is not writable.'
output = QFileInfo(self.uri.filePath(layer_name + '.tif'))
source = QFileInfo(raster_layer.source())
if source.exists() and source.suffix() in ['tiff', 'tif']:
# If it's tiff file based.
QFile.copy(source.absoluteFilePath(), output.absoluteFilePath())
else:
# If it's not file based.
renderer = raster_layer.renderer()
provider = raster_layer.dataProvider()
crs = raster_layer.crs()
pipe = QgsRasterPipe()
pipe.set(provider.clone())
pipe.set(renderer.clone())
file_writer = QgsRasterFileWriter(output.absoluteFilePath())
file_writer.Mode(1)
file_writer.writeRaster(pipe, provider.xSize(), provider.ySize(),
provider.extent(), crs)
del file_writer
if save_style:
style_path = QFileInfo(self.uri.filePath(layer_name + '.qml'))
raster_layer.saveNamedStyle(style_path.absoluteFilePath())
assert output.exists()
return True, output.baseName()
def btnBrowseDefectsFile_clicked(self):
file_path = QFileDialog.getOpenFileName(self,
tr("Choose defects file"),
self.input_xlsx_path,
"Defects layer (*.shp)")[0]
file_info = QFileInfo(file_path)
self.lineEditDefectsFile.setText(file_info.absoluteFilePath())
def _add_vector_layer(self, vector_layer, layer_name):
"""Add a vector layer to the folder.
:param vector_layer: The layer to add.
:type vector_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if not self.is_writable():
return False, 'The destination is not writable.'
output = QFileInfo(
self.uri.filePath(layer_name + '.' + self._default_vector_format))
driver_mapping = {
'shp': 'ESRI Shapefile',
'kml': 'KML',
'geojson': 'GeoJSON',
}
QgsVectorFileWriter.writeAsVectorFormat(
vector_layer, output.absoluteFilePath(), 'utf-8',
vector_layer.crs(), driver_mapping[self._default_vector_format])
return True, output.baseName()
def btnBrowseImportJar_clicked(self):
file_path = QFileDialog.getOpenFileName(
self, tr("Open import jar file"), self.import_jar_path,
"jar (*.jar *.JAR)")[0]
file_info = QFileInfo(file_path)
self.lineEditImportJar.setText(file_info.absoluteFilePath())
def btnBrowseProjectsDatabase_clicked(self):
file_path = QFileDialog.getOpenFileName(self, tr(
"Choose projects definitions database"),
self.projects_database_path,
"SQLite (*.sqlite *.db *.DB)")[0]
file_info = QFileInfo(file_path)
self.lineEditProjectsDatabase.setText(file_info.absoluteFilePath())
def selFile(self):
sf = QFileInfo(QFileDialog.getOpenFileName(self, 'Open logo file', QDir.homePath(), 'Image files (*.png)'))
f = sf.fileName()
if f!='':
self.logopath = sf.absoluteFilePath()
self.label.setPixmap(QPixmap(self.logopath))
return f
def selFile(self):
sf = QFileInfo(QFileDialog.getOpenFileName(self, 'Select SLD file', '', 'SLD files (*.sld)'))
f = sf.fileName()
if f!='':
df = os.path.join(os.path.join(self.plugin_dir, 'sld'), f)
shutil.copy(sf.absoluteFilePath(), df)
return f
def selFile(self):
sf = QFileInfo(QFileDialog.getOpenFileName(self, 'Select SLD file', '', 'SLD files (*.sld)')[0])
f = sf.fileName()
if f!='':
df = os.path.join(os.path.join(self.plugin_dir, 'sld'), f)
if not (os.path.samefile(sf, df)):
shutil.copy(sf.absoluteFilePath(), df)
return f
def _add_vector_layer(self, vector_layer, layer_name, save_style=False):
"""Add a vector layer to the folder.
:param vector_layer: The layer to add.
:type vector_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:param save_style: If we have to save a QML too. Default to False.
:type save_style: bool
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if not self.is_writable():
return False, 'The destination is not writable.'
output = QFileInfo(
self.uri.filePath(layer_name + '.' + self._default_vector_format))
driver_mapping = {
'shp': 'ESRI Shapefile',
'kml': 'KML',
'geojson': 'GeoJSON',
}
QgsVectorFileWriter.writeAsVectorFormat(
vector_layer,
output.absoluteFilePath(),
'utf-8',
QgsCoordinateTransform(), # No tranformation
driver_mapping[self._default_vector_format])
if save_style:
style_path = QFileInfo(self.uri.filePath(layer_name + '.qml'))
vector_layer.saveNamedStyle(style_path.absoluteFilePath())
assert output.exists()
return True, output.baseName()
def _add_vector_layer(self, vector_layer, layer_name, save_style=False):
"""Add a vector layer to the folder.
:param vector_layer: The layer to add.
:type vector_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:param save_style: If we have to save a QML too. Default to False.
:type save_style: bool
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
if not self.is_writable():
return False, 'The destination is not writable.'
output = QFileInfo(
self.uri.filePath(layer_name + '.' + self._default_vector_format))
driver_mapping = {
'shp': 'ESRI Shapefile',
'kml': 'KML',
'geojson': 'GeoJSON',
}
QgsVectorFileWriter.writeAsVectorFormat(
vector_layer,
output.absoluteFilePath(),
'utf-8',
QgsCoordinateTransform(), # No tranformation
driver_mapping[self._default_vector_format])
if save_style:
style_path = QFileInfo(self.uri.filePath(layer_name + '.qml'))
vector_layer.saveNamedStyle(style_path.absoluteFilePath())
assert output.exists()
return True, output.baseName()
def outFile(self):
of = QFileInfo(
QFileDialog.getSaveFileName(self, 'Output map file',
QDir.homePath(),
'PDF files (*.pdf)')[0])
f = of.fileName()
if f != '':
self.lineEdit_3.setText(of.absoluteFilePath())
return f
def btnBrowseOutputFile_clicked(self):
file_path = QFileDialog.getSaveFileName(
self,
tr("Choose interlis transfer file"),
"",
# self.input_itf_path,
"ITF (*.itf *.ITF)")[0]
file_info = QFileInfo(file_path)
self.lineEditOutputFile.setText(file_info.absoluteFilePath())
def selFile(self):
sf = QFileInfo(
QFileDialog.getOpenFileName(self, 'Open logo file',
QDir.homePath(),
'Image files (*.png)')[0])
f = sf.fileName()
if f != '':
self.logopath = sf.absoluteFilePath()
self.label.setPixmap(QPixmap(self.logopath))
return f
def layer_uri(self, layer_name):
"""Get layer URI.
:param layer_name: The name of the layer to fetch.
:type layer_name: str
:return: The URI to the layer.
:rtype: str
.. versionadded:: 4.0
"""
layers = self.layers()
for layer, extension in product(layers, EXTENSIONS):
one_file = QFileInfo(self.uri.filePath(layer + '.' + extension))
if one_file.exists():
if one_file.baseName() == layer_name:
return one_file.absoluteFilePath()
else:
return None
def layer_uri(self, layer_name):
"""Get layer URI.
:param layer_name: The name of the layer to fetch.
:type layer_name: str
:return: The URI to the layer.
:rtype: str
.. versionadded:: 4.0
"""
layers = self.layers()
for layer, extension in product(layers, EXTENSIONS):
one_file = QFileInfo(
self.uri.filePath(layer + '.' + extension))
if one_file.exists():
if one_file.baseName() == layer_name:
return one_file.absoluteFilePath()
else:
return None
def _add_tabular_layer(self, tabular_layer, layer_name):
"""Add a tabular layer to the folder.
:param tabular_layer: The layer to add.
:type tabular_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
output = QFileInfo(self.uri.filePath(layer_name + '.csv'))
QgsVectorFileWriter.writeAsVectorFormat(tabular_layer,
output.absoluteFilePath(),
'utf-8', None, 'CSV')
return True, output.baseName()
def on_btnBrowseInputFile_clicked(self):
file_path = QFileDialog.getOpenFileName(
self, tr("Choose interlis transfer file"), self.input_itf_path,
"ITF (*.itf *.ITF)")
file_info = QFileInfo(file_path)
self.lineEditInputFile.setText(file_info.absoluteFilePath())
def btnBrowseProjectsRootDir_clicked(self):
dir_path = QFileDialog.getExistingDirectory(self, tr(
"Choose projects root directory"), self.projects_root_directory)
dir_info = QFileInfo(dir_path)
self.lineEditProjectsRootDir.setText(dir_info.absoluteFilePath())
def outFile(self):
of = QFileInfo(QFileDialog.getSaveFileName(self, 'Output map file', QDir.homePath(), 'PDF files (*.pdf)'))
f = of.fileName()
if f!='':
self.lineEdit_3.setText(of.absoluteFilePath())
return f
def test_create_geopackage(self):
"""Test if we can store geopackage."""
# Create a geopackage from an empty file.
path = QFileInfo(mktemp() + '.gpkg')
self.assertFalse(path.exists())
data_store = GeoPackage(path)
path.refresh()
self.assertTrue(path.exists())
# Let's add a vector layer.
layer_name = 'flood_test'
layer = standard_data_path('hazard', 'flood_multipart_polygons.shp')
vector_layer = QgsVectorLayer(layer, 'Flood', 'ogr')
result = data_store.add_layer(vector_layer, layer_name)
self.assertTrue(result[0])
# We should have one layer.
layers = data_store.layers()
self.assertEqual(len(layers), 1)
self.assertIn(layer_name, layers)
# Add the same layer with another name.
layer_name = 'another_vector_flood'
result = data_store.add_layer(vector_layer, layer_name)
self.assertTrue(result[0])
# We should have two layers.
layers = data_store.layers()
self.assertEqual(len(layers), 2)
self.assertIn(layer_name, layers)
# Test the URI of the new layer.
expected = path.absoluteFilePath() + '|layername=' + layer_name
self.assertEqual(data_store.layer_uri(layer_name), expected)
# Test a fake layer.
self.assertIsNone(data_store.layer_uri('fake_layer'))
# Test to add a raster
layer_name = 'raster_flood'
layer = standard_data_path('hazard', 'classified_hazard.tif')
raster_layer = QgsRasterLayer(layer, layer_name)
result = data_store.add_layer(raster_layer, layer_name)
self.assertTrue(result[0])
# We should have 3 layers inside.
layers = data_store.layers()
self.assertEqual(len(layers), 3)
# Check the URI for the raster layer.
expected = 'GPKG:' + path.absoluteFilePath() + ':' + layer_name
self.assertEqual(data_store.layer_uri(layer_name), expected)
# Add a second raster.
layer_name = 'big raster flood'
self.assertTrue(data_store.add_layer(raster_layer, layer_name))
self.assertEqual(len(data_store.layers()), 4)
# Test layer without geometry
layer = load_test_vector_layer(
'gisv4', 'impacts', 'exposure_summary_table.csv')
tabular_layer_name = 'breakdown'
result = data_store.add_layer(layer, tabular_layer_name)
self.assertTrue(result[0])
