def testStringToSafeFilename(self):
self.assertEqual(
QgsFileUtils.stringToSafeFilename('my FiLe v2.0_new.tif'),
'my FiLe v2.0_new.tif')
self.assertEqual(
QgsFileUtils.stringToSafeFilename(
'rendered map_final? rev (12-03-1017)_real/\\?%*:|"<>.tif'),
'rendered map_final_ rev (12-03-1017)_real__________.tif')
def test_represent_file_size(self):
"""
Test QgsFileUtils.representFileSize
"""
self.assertEqual(QgsFileUtils.representFileSize(1023), '1023 B')
self.assertEqual(QgsFileUtils.representFileSize(1024), '1 KB')
self.assertEqual(QgsFileUtils.representFileSize(1048576), '1.00 MB')
self.assertEqual(QgsFileUtils.representFileSize(9876543210), '9.20 GB')
def testStringToSafeFilename(self):
self.assertEqual(
QgsFileUtils.stringToSafeFilename('my FiLe v2.0_new.tif'),
'my FiLe v2.0_new.tif')
self.assertEqual(
QgsFileUtils.stringToSafeFilename(
'rendered map_final? rev (12-03-1017)_real@#$&*#%&*$!!@$%^&(*(.tif'
),
'rendered map_final_ rev _12-03-1017__real____________________.tif'
)
def testAddExtensionFromFilter(self):
self.assertEqual(
QgsFileUtils.addExtensionFromFilter('test', 'TIFF Files (*.tif)'),
'test.tif')
self.assertEqual(
QgsFileUtils.addExtensionFromFilter('test', 'TIFF Files (*.tif)'),
'test.tif')
self.assertEqual(QgsFileUtils.addExtensionFromFilter('test.tif', ''),
'test.tif')
self.assertEqual(
QgsFileUtils.addExtensionFromFilter('test.tif',
'BMP Files (*.bmp)'),
'test.tif.bmp')
self.assertEqual(
QgsFileUtils.addExtensionFromFilter('test.tif',
'TIFF Files (*.tiff)'),
'test.tif.tiff')
self.assertEqual(
QgsFileUtils.addExtensionFromFilter('test.tif',
'TIFF Files (*.tif *.tiff)'),
'test.tif')
self.assertEqual(
QgsFileUtils.addExtensionFromFilter('test.tif',
'TIFF Files (*.TIF *.TIFF)'),
'test.tif')
self.assertEqual(
QgsFileUtils.addExtensionFromFilter('test.tif', 'All Files (*.*)'),
'test.tif')
self.assertEqual(
QgsFileUtils.addExtensionFromFilter('test', 'All Files (*.*)'),
'test')
def test_sidecar_files_for_path(self):
"""
Test QgsFileUtils.sidecarFilesForPath
"""
# file which doesn't exist
self.assertFalse(QgsFileUtils.sidecarFilesForPath('/not a valid path'))
# a directory
self.assertFalse(QgsFileUtils.sidecarFilesForPath(unitTestDataPath()))
# not a spatial data file
self.assertFalse(QgsFileUtils.sidecarFilesForPath(f'{unitTestDataPath()}/kbs.qgs'))
# shapefile
self.assertEqual(QgsFileUtils.sidecarFilesForPath(f'{unitTestDataPath()}/lines.shp'),
{f'{unitTestDataPath()}/lines.shx', f'{unitTestDataPath()}/lines.dbf',
f'{unitTestDataPath()}/lines.prj'})
# gpkg
self.assertFalse(QgsFileUtils.sidecarFilesForPath(f'{unitTestDataPath()}/mixed_layers.gpkg'))
# MapInfo TAB file
self.assertEqual(QgsFileUtils.sidecarFilesForPath(f'{unitTestDataPath()}/ogr_types.tab'),
{f'{unitTestDataPath()}/ogr_types.dat', f'{unitTestDataPath()}/ogr_types.id',
f'{unitTestDataPath()}/ogr_types.map'})
# GML
self.assertEqual(QgsFileUtils.sidecarFilesForPath(f'{unitTestDataPath()}/invalidgeometries.gml'),
{f'{unitTestDataPath()}/invalidgeometries.gfs'})
# netcdf
self.assertEqual(QgsFileUtils.sidecarFilesForPath(f'{unitTestDataPath()}/landsat2.nc'),
{f'{unitTestDataPath()}/landsat2.nc.aux.xml'})
# tif
self.assertEqual(QgsFileUtils.sidecarFilesForPath(f'{unitTestDataPath()}/ALLINGES_RGF93_CC46_1_1.tif'),
{f'{unitTestDataPath()}/ALLINGES_RGF93_CC46_1_1.tfw'})
def testExtensionsFromFilter(self):
self.assertEqual(QgsFileUtils.extensionsFromFilter(''), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('bad'), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('*'), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('*.'), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('Tiff files'), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('(*.)'), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('PNG Files (*.png)'), ['png'])
self.assertEqual(QgsFileUtils.extensionsFromFilter('PNG Files (*.PNG)'), ['PNG'])
self.assertEqual(QgsFileUtils.extensionsFromFilter('Geotiff Files (*.tiff *.tif)'), ['tiff', 'tif'])
def testExtensionsFromFilter(self):
self.assertEqual(QgsFileUtils.extensionsFromFilter(''), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('bad'), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('*'), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('*.'), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('Tiff files'), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('(*.)'), [])
self.assertEqual(QgsFileUtils.extensionsFromFilter('PNG Files (*.png)'), ['png'])
self.assertEqual(QgsFileUtils.extensionsFromFilter('PNG Files (*.PNG)'), ['PNG'])
self.assertEqual(QgsFileUtils.extensionsFromFilter('Geotiff Files (*.tiff *.tif)'), ['tiff', 'tif'])
def testAddExtensionFromFilter(self):
self.assertEqual(QgsFileUtils.addExtensionFromFilter('test', 'TIFF Files (*.tif)'), 'test.tif')
self.assertEqual(QgsFileUtils.addExtensionFromFilter('test', 'TIFF Files (*.tif)'), 'test.tif')
self.assertEqual(QgsFileUtils.addExtensionFromFilter('test.tif', ''), 'test.tif')
self.assertEqual(QgsFileUtils.addExtensionFromFilter('test.tif', 'BMP Files (*.bmp)'), 'test.tif.bmp')
self.assertEqual(QgsFileUtils.addExtensionFromFilter('test.tif', 'TIFF Files (*.tiff)'), 'test.tif.tiff')
self.assertEqual(QgsFileUtils.addExtensionFromFilter('test.tif', 'TIFF Files (*.tif *.tiff)'), 'test.tif')
self.assertEqual(QgsFileUtils.addExtensionFromFilter('test.tif', 'TIFF Files (*.TIF *.TIFF)'), 'test.tif')
self.assertEqual(QgsFileUtils.addExtensionFromFilter('test.tif', 'All Files (*.*)'), 'test.tif')
self.assertEqual(QgsFileUtils.addExtensionFromFilter('test', 'All Files (*.*)'), 'test')
def testAutoFinder(self):
temp_folder = tempfile.mkdtemp()
base_folder = os.path.join(temp_folder, 'base_level')
os.mkdir(base_folder)
side_fold = os.path.join(temp_folder, 'sidefold')
os.mkdir(side_fold)
nest = os.path.join(base_folder, 'direct_nest')
os.mkdir(nest)
side_nest = os.path.join(side_fold, 'side_nest')
os.mkdir(side_nest)
filename = "findme.txt"
# unexisting
files = QgsFileUtils.findFile(filename, nest, 1, 4)
self.assertEqual(len(files), 0)
# out of depth
files = QgsFileUtils.findFile(filename, nest, 0, 4)
self.assertEqual(len(files), 0)
# too close
files = QgsFileUtils.findFile(filename, nest, 1, 13)
self.assertEqual(len(files), 0)
# side nest
with open(os.path.join(side_nest, filename), 'w+'):
files = QgsFileUtils.findFile(os.path.join(base_folder, filename))
self.assertEqual(
files[0],
os.path.join(side_nest, filename).replace(os.sep, '/'))
# side + side nest = 2
with open(os.path.join(side_fold, filename), 'w+'):
files = QgsFileUtils.findFile(filename, base_folder, 3, 4)
self.assertEqual(len(files), 2)
# up
with open(os.path.join(temp_folder, filename), 'w+'):
files = QgsFileUtils.findFile(filename, base_folder, 3, 4)
self.assertEqual(
files[0],
os.path.join(temp_folder, filename).replace(os.sep, '/'))
# nest
with open(os.path.join(nest, filename), 'w+'):
files = QgsFileUtils.findFile(os.path.join(base_folder, filename))
self.assertEqual(files[0],
os.path.join(nest, filename).replace(os.sep, '/'))
# base level
with open(os.path.join(base_folder, filename), 'w+'):
files = QgsFileUtils.findFile(filename, base_folder, 2, 4)
self.assertEqual(
files[0],
os.path.join(base_folder, filename).replace(os.sep, '/'))
# invalid path, too deep
files = QgsFileUtils.findFile(filename, os.path.join(nest, 'nest2'), 2,
4)
self.assertEqual(files[0],
os.path.join(nest, filename).replace(os.sep, '/'))
def object_to_qlr(
obj,
input_file,
output_path,
context: Context,
use_relative_paths: bool = False) -> Tuple[bool, Optional[str]]:
"""
Converts an ESRI object to QLR
"""
root_node, _ = LayerConverter.object_to_layers_and_tree(
obj, input_file, context)
output_path = QgsFileUtils.ensureFileNameHasExtension(
output_path, ['qlr'])
file = QFile(output_path)
if not file.open(QFile.WriteOnly | QFile.Truncate):
return False, file.errorString()
rw_context = QgsReadWriteContext()
if not use_relative_paths:
rw_context.setPathResolver(QgsPathResolver())
else:
rw_context.setPathResolver(QgsPathResolver(output_path))
doc = QDomDocument("qgis-layer-definition")
res, error = QgsLayerDefinition.exportLayerDefinition(
doc, root_node.children(), rw_context)
if res:
stream = QTextStream(file)
doc.save(stream, 2)
return True, None
return res, error
def _export_service(self):
service_type = self.get_current_service_type()
service_id = self.get_current_service_id(service_type)
file, _ = QFileDialog.getSaveFileName(self, self.tr('Export Service'),
QDir.homePath() + '/{}.json'.format(service_id), 'JSON Files (*.json)')
if not file:
return
file = QgsFileUtils.ensureFileNameHasExtension(file, ['json'])
if SERVICE_MANAGER.export_service(service_type, service_id, file):
self.message_bar.pushMessage(
self.tr("Service exported"), Qgis.Success, 5)
else:
self.message_bar.pushMessage(
self.tr("An error occurred while exporting service"), Qgis.Critical, 5)
def testSplitPathToComponents(self):
self.assertEqual(
QgsFileUtils.splitPathToComponents('/home/user/Pictures/test.png'),
["/", "home", "user", "Pictures", "test.png"])
self.assertEqual(
QgsFileUtils.splitPathToComponents('/home/user/Pictures/'),
["/", "home", "user", "Pictures"])
self.assertEqual(
QgsFileUtils.splitPathToComponents('/home/user/Pictures'),
["/", "home", "user", "Pictures"])
self.assertEqual(QgsFileUtils.splitPathToComponents('/home/user'),
["/", "home", "user"])
self.assertEqual(QgsFileUtils.splitPathToComponents('/home'),
["/", "home"])
self.assertEqual(QgsFileUtils.splitPathToComponents('/'), ["/"])
self.assertEqual(QgsFileUtils.splitPathToComponents(''), [])
self.assertEqual(QgsFileUtils.splitPathToComponents('c:/home/user'),
["c:", "home", "user"])
def _save_column_mapping(self):
"""
Exports the current column mapping to a JSON definition file
"""
config = RegistryConfig()
prev_folder = config.read(["LastImportConfigFolder"]).get("LastImportConfigFolder")
if not prev_folder:
prev_folder = QDir.homePath()
dest_path, _ = QFileDialog.getSaveFileName(self, self.tr("Save Configuration"),
prev_folder,
"{0} (*.json)".format(self.tr('Configuration files')))
if not dest_path:
return
dest_path = QgsFileUtils.ensureFileNameHasExtension(dest_path, ['.json'])
config.write({"LastImportConfigFolder": QFileInfo(dest_path).path()})
with open(dest_path, 'wt') as f:
f.write(json.dumps(self._get_column_config(), indent=4))
def saveAsScriptFile(self, index=None):
tabWidget = self.tabEditorWidget.currentWidget()
if not index:
index = self.tabEditorWidget.currentIndex()
if not tabWidget.path:
fileName = self.tabEditorWidget.tabText(index).replace('*',
'') + '.py'
folder = self.settings.value("pythonConsole/lastDirPath",
QDir.homePath())
pathFileName = os.path.join(folder, fileName)
fileNone = True
else:
pathFileName = tabWidget.path
fileNone = False
saveAsFileTr = QCoreApplication.translate("PythonConsole",
"Save File As")
filename, filter = QFileDialog.getSaveFileName(self, saveAsFileTr,
pathFileName,
"Script file (*.py)")
if filename:
filename = QgsFileUtils.ensureFileNameHasExtension(
filename, ['py'])
try:
tabWidget.save(filename)
except (IOError, OSError) as error:
msgText = QCoreApplication.translate(
'PythonConsole',
'The file <b>{0}</b> could not be saved. Error: {1}'
).format(tabWidget.path, error.strerror)
self.callWidgetMessageBarEditor(msgText, 2, False)
if fileNone:
tabWidget.path = None
else:
tabWidget.path = pathFileName
return
if not fileNone:
self.updateTabListScript(pathFileName, action='remove')
def testFileMatchesFilter(self):
self.assertFalse(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif', ''))
self.assertFalse(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif', 'bad'))
self.assertFalse(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif', '*'))
self.assertFalse(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif', '*.'))
self.assertFalse(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif', 'Tiff files'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif', '(*.*)'))
self.assertFalse(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif',
'PNG Files (*.png)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif',
'Tif Files (*.tif)'))
self.assertFalse(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif',
'PNG Files (*.PNG)'))
self.assertFalse(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif',
'Tif Files (*.TIF)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter('/home/me/test.tif',
'Geotiff Files (*.tiff *.tif)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter('/home/me/test.tiff',
'Geotiff Files (*.tiff *.tif)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter(
'/home/me/test.TIFF', 'Geotiff Files (*.tiff *.tif *.TIFF)'))
self.assertFalse(
QgsFileUtils.fileMatchesFilter(
'/home/me/test.tif', 'PNG Files (*.png);;BMP Files (*.bmp)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter(
'/home/me/test.bmp', 'PNG Files (*.png);;BMP Files (*.bmp)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter(
'/home/me/test.png', 'PNG Files (*.png);;BMP Files (*.bmp)'))
self.assertFalse(
QgsFileUtils.fileMatchesFilter('/home/me/test.png',
'EPT files (ept.json)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter('/home/me/ept.json',
'EPT files (ept.json)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter('/home/me/ept.json',
'EPT files (ept.json EPT.JSON)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter('/home/me/EPT.JSON',
'EPT files (ept.json EPT.JSON)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter(
'/home/me/ept.json',
'EPT files (ept.json);;Entwine files (entwine.json)'))
self.assertTrue(
QgsFileUtils.fileMatchesFilter(
'/home/me/entwine.json',
'EPT files (ept.json);;Entwine files (entwine.json)'))
self.assertFalse(
QgsFileUtils.fileMatchesFilter(
'/home/me/ep.json',
'EPT files (ept.json);;Entwine files (entwine.json)'))
def testEnsureFileNameHasExtension(self):
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('', ['']), '')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('', []), '')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('test', []),
'test')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('', ['.tif']),
'')
self.assertEqual(
QgsFileUtils.ensureFileNameHasExtension('test', ['.tif']),
'test.tif')
self.assertEqual(
QgsFileUtils.ensureFileNameHasExtension('test', ['tif']),
'test.tif')
self.assertEqual(
QgsFileUtils.ensureFileNameHasExtension('test.tif', []),
'test.tif')
self.assertEqual(
QgsFileUtils.ensureFileNameHasExtension('test.tif', ['bmp']),
'test.tif.bmp')
self.assertEqual(
QgsFileUtils.ensureFileNameHasExtension('test.tif', ['tiff']),
'test.tif.tiff')
self.assertEqual(
QgsFileUtils.ensureFileNameHasExtension('test.tif',
['tiff', 'tif']),
'test.tif')
self.assertEqual(
QgsFileUtils.ensureFileNameHasExtension('test.tif',
['TIFF', 'TIF']),
'test.tif')
def testFindClosestExistingPath(self):
self.assertEqual(QgsFileUtils.findClosestExistingPath(''), '')
self.assertEqual(QgsFileUtils.findClosestExistingPath('.'), '')
self.assertEqual(
QgsFileUtils.findClosestExistingPath('just_a_filename'), '')
self.assertEqual(
QgsFileUtils.findClosestExistingPath('just_a_filename.txt'), '')
self.assertEqual(
QgsFileUtils.findClosestExistingPath(
'a_very_unlikely_path_to_really_exist/because/no_one_would_have_a_folder_called/MapInfo is the bestest/'
), '')
# sorry anyone not on linux!
self.assertEqual(
QgsFileUtils.findClosestExistingPath(
'/usr/youve_been_hacked/by_the_l77t_krew'), '/usr')
base_path = tempfile.mkdtemp()
file = os.path.join(base_path, 'test.csv')
with open(file, 'wt') as f:
f.write('\n')
self.assertEqual(
QgsFileUtils.findClosestExistingPath(
os.path.join(base_path, 'a file name.bmp')),
base_path) # non-existent file
self.assertEqual(QgsFileUtils.findClosestExistingPath(file),
base_path) # real file!
self.assertEqual(
QgsFileUtils.findClosestExistingPath(
os.path.join(base_path, 'non/existent/subfolder')), base_path)
sub_folder1 = os.path.join(base_path, 'subfolder1')
os.mkdir(sub_folder1)
sub_folder2 = os.path.join(sub_folder1, 'subfolder2')
os.mkdir(sub_folder2)
bad_sub_folder = os.path.join(sub_folder2, 'nooo')
self.assertEqual(QgsFileUtils.findClosestExistingPath(bad_sub_folder),
sub_folder2)
self.assertEqual(QgsFileUtils.findClosestExistingPath(sub_folder2),
sub_folder2)
self.assertEqual(
QgsFileUtils.findClosestExistingPath(sub_folder2 + '/.'),
sub_folder2)
self.assertEqual(
QgsFileUtils.findClosestExistingPath(sub_folder2 + '/..'),
sub_folder1)
self.assertEqual(
QgsFileUtils.findClosestExistingPath(sub_folder2 + '/../ddddddd'),
sub_folder1)
self.assertEqual(
QgsFileUtils.findClosestExistingPath(sub_folder2 +
'/../subfolder2'),
sub_folder2)
self.assertEqual(
QgsFileUtils.findClosestExistingPath(
sub_folder2 + '/../subfolder2/zxcv/asfdasd'), sub_folder2)
def testFindClosestExistingPath(self):
self.assertEqual(QgsFileUtils.findClosestExistingPath(''), '')
self.assertEqual(QgsFileUtils.findClosestExistingPath('.'), '')
self.assertEqual(QgsFileUtils.findClosestExistingPath('just_a_filename'), '')
self.assertEqual(QgsFileUtils.findClosestExistingPath('just_a_filename.txt'), '')
self.assertEqual(QgsFileUtils.findClosestExistingPath('a_very_unlikely_path_to_really_exist/because/no_one_would_have_a_folder_called/MapInfo is the bestest/'), '')
# sorry anyone not on linux!
self.assertEqual(QgsFileUtils.findClosestExistingPath('/usr/youve_been_hacked/by_the_l77t_krew'), '/usr')
base_path = tempfile.mkdtemp()
file = os.path.join(base_path, 'test.csv')
with open(file, 'wt') as f:
f.write('\n')
self.assertEqual(QgsFileUtils.findClosestExistingPath(os.path.join(base_path, 'a file name.bmp')), base_path) # non-existent file
self.assertEqual(QgsFileUtils.findClosestExistingPath(file), base_path) # real file!
self.assertEqual(QgsFileUtils.findClosestExistingPath(os.path.join(base_path, 'non/existent/subfolder')), base_path)
sub_folder1 = os.path.join(base_path, 'subfolder1')
os.mkdir(sub_folder1)
sub_folder2 = os.path.join(sub_folder1, 'subfolder2')
os.mkdir(sub_folder2)
bad_sub_folder = os.path.join(sub_folder2, 'nooo')
self.assertEqual(QgsFileUtils.findClosestExistingPath(bad_sub_folder), sub_folder2)
self.assertEqual(QgsFileUtils.findClosestExistingPath(sub_folder2), sub_folder2)
self.assertEqual(QgsFileUtils.findClosestExistingPath(sub_folder2 + '/.'), sub_folder2)
self.assertEqual(QgsFileUtils.findClosestExistingPath(sub_folder2 + '/..'), sub_folder1)
self.assertEqual(QgsFileUtils.findClosestExistingPath(sub_folder2 + '/../ddddddd'), sub_folder1)
self.assertEqual(QgsFileUtils.findClosestExistingPath(sub_folder2 + '/../subfolder2'), sub_folder2)
self.assertEqual(QgsFileUtils.findClosestExistingPath(sub_folder2 + '/../subfolder2/zxcv/asfdasd'), sub_folder2)
def testWildcardsFromFilter(self):
self.assertEqual(QgsFileUtils.wildcardsFromFilter(''), '')
self.assertEqual(QgsFileUtils.wildcardsFromFilter('bad'), '')
self.assertEqual(QgsFileUtils.wildcardsFromFilter('*'), '')
self.assertEqual(QgsFileUtils.wildcardsFromFilter('*.'), '')
self.assertEqual(QgsFileUtils.wildcardsFromFilter('Tiff files'), '')
self.assertEqual(QgsFileUtils.wildcardsFromFilter('(*.*)'), '*.*')
self.assertEqual(QgsFileUtils.wildcardsFromFilter('PNG Files (*.png)'),
'*.png')
self.assertEqual(
QgsFileUtils.wildcardsFromFilter('Tif Files (*.tif)'), '*.tif')
self.assertEqual(QgsFileUtils.wildcardsFromFilter('PNG Files (*.PNG)'),
'*.PNG')
self.assertEqual(
QgsFileUtils.wildcardsFromFilter('Geotiff Files (*.tiff *.tif)'),
'*.tiff *.tif')
self.assertEqual(
QgsFileUtils.wildcardsFromFilter(
'Geotiff Files (*.tiff *.tif *.TIFF)'), '*.tiff *.tif *.TIFF')
self.assertEqual(
QgsFileUtils.wildcardsFromFilter('EPT files (ept.json)'),
'ept.json')
self.assertEqual(
QgsFileUtils.wildcardsFromFilter('EPT files (ept.json EPT.JSON)'),
'ept.json EPT.JSON')
def test_rename_dataset(self):
"""
Test QgsFileUtils.renameDataset
"""
base_path = tempfile.mkdtemp()
for ext in ['shp', 'dbf', 'prj', 'qml', 'shx']:
shutil.copy(f'{unitTestDataPath()}/lines.{ext}',
f'{base_path}/lines.{ext}')
shutil.copy(f'{unitTestDataPath()}/lines.{ext}',
f'{base_path}/lines.{ext}')
self.assertTrue(os.path.exists(f'{base_path}/lines.shp'))
res, error = QgsFileUtils.renameDataset(
f'{base_path}/lines.shp', f'{base_path}/other_lines.shp')
self.assertTrue(res)
for ext in ['shp', 'dbf', 'prj', 'qml', 'shx']:
self.assertTrue(os.path.exists(f'{base_path}/other_lines.{ext}'))
self.assertFalse(os.path.exists(f'{base_path}/lines.{ext}'))
# skip qml file
res, error = QgsFileUtils.renameDataset(
f'{base_path}/other_lines.shp', f'{base_path}/other_lines2.shp',
Qgis.FileOperationFlags())
self.assertTrue(res)
for ext in ['shp', 'dbf', 'prj', 'shx']:
self.assertTrue(os.path.exists(f'{base_path}/other_lines2.{ext}'))
self.assertFalse(os.path.exists(f'{base_path}/other_lines.{ext}'))
self.assertFalse(os.path.exists(f'{base_path}/other_lines2.qml'))
self.assertTrue(os.path.exists(f'{base_path}/other_lines.qml'))
# try changing extension -- sidecars won't be renamed
res, error = QgsFileUtils.renameDataset(
f'{base_path}/other_lines2.shp', f'{base_path}/other_lines2.txt',
Qgis.FileOperationFlags())
self.assertFalse(error)
self.assertTrue(res)
self.assertFalse(os.path.exists(f'{base_path}/other_lines2.shp'))
self.assertTrue(os.path.exists(f'{base_path}/other_lines2.txt'))
for ext in ['dbf', 'prj', 'shx']:
self.assertTrue(os.path.exists(f'{base_path}/other_lines2.{ext}'))
for ext in ['shp', 'dbf', 'prj', 'qml', 'shx']:
shutil.copy(f'{unitTestDataPath()}/lines.{ext}',
f'{base_path}/ll.{ext}')
shutil.copy(f'{unitTestDataPath()}/lines.{ext}',
f'{base_path}/ll.{ext}')
# file name clash
with open(f'{base_path}/yy.shp', 'wt') as f:
f.write('')
res, error = QgsFileUtils.renameDataset(f'{base_path}/ll.shp',
f'{base_path}/yy.shp',
Qgis.FileOperationFlags())
self.assertFalse(res)
self.assertTrue(error)
# nothing should be renamed
for ext in ['shp', 'dbf', 'prj', 'qml', 'shx']:
self.assertTrue(os.path.exists(f'{base_path}/ll.{ext}'))
# sidecar clash
with open(f'{base_path}/yyy.shx', 'wt') as f:
f.write('')
res, error = QgsFileUtils.renameDataset(f'{base_path}/ll.shp',
f'{base_path}/yyy.shp')
self.assertFalse(res)
self.assertTrue(error)
# no files should have been renamed
for ext in ['shp', 'dbf', 'prj', 'qml']:
self.assertTrue(os.path.exists(f'{base_path}/ll.{ext}'))
self.assertFalse(os.path.exists(f'{base_path}/yyy.{ext}'))
self.assertTrue(os.path.exists(f'{base_path}/ll.shx'))
# try renaming missing file
res, error = QgsFileUtils.renameDataset('/not a file.txt',
f'{base_path}/not a file.txt',
Qgis.FileOperationFlags())
self.assertFalse(res)
self.assertTrue(error)
def testEnsureFileNameHasExtension(self):
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('', ['']), '')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('', []), '')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('test', []), 'test')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('', ['.tif']), '')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('test', ['.tif']), 'test.tif')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('test', ['tif']), 'test.tif')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('test.tif', []), 'test.tif')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('test.tif', ['bmp']), 'test.tif.bmp')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('test.tif', ['tiff']), 'test.tif.tiff')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('test.tif', ['tiff', 'tif']), 'test.tif')
self.assertEqual(QgsFileUtils.ensureFileNameHasExtension('test.tif', ['TIFF', 'TIF']), 'test.tif')
def saveModel(self, saveAs) -> bool:
if not self.validateSave(QgsModelDesignerDialog.SaveAction.SaveAsFile):
return False
model_name_matched_file_name = self.model().modelNameMatchesFilePath()
if self.model().sourceFilePath() and not saveAs:
filename = self.model().sourceFilePath()
else:
if self.model().sourceFilePath():
initial_path = Path(self.model().sourceFilePath())
elif self.model().name():
initial_path = Path(ModelerUtils.modelsFolders()[0]) / (
self.model().name() + '.model3')
else:
initial_path = Path(ModelerUtils.modelsFolders()[0])
filename, _ = QFileDialog.getSaveFileName(
self, self.tr('Save Model'), initial_path.as_posix(),
self.tr('Processing models (*.model3 *.MODEL3)'))
if not filename:
return False
filename = QgsFileUtils.ensureFileNameHasExtension(
filename, ['model3'])
self.model().setSourceFilePath(filename)
if not self.model().name() or self.model().name() == self.tr(
'model'):
self.setModelName(Path(filename).stem)
elif saveAs and model_name_matched_file_name:
# if saving as, and the model name used to match the filename, then automatically update the
# model name to match the new file name
self.setModelName(Path(filename).stem)
if not self.model().toFile(filename):
if saveAs:
QMessageBox.warning(
self, self.tr('I/O error'),
self.tr('Unable to save edits. Reason:\n {0}').format(
str(sys.exc_info()[1])))
else:
QMessageBox.warning(
self, self.tr("Can't save model"),
self.
tr("This model can't be saved in its original location (probably you do not "
"have permission to do it). Please, use the 'Save as…' option."
))
return False
self.update_model.emit()
if saveAs:
self.messageBar().pushMessage(
"",
self.tr("Model was saved to <a href=\"{}\">{}</a>").format(
QUrl.fromLocalFile(filename).toString(),
QDir.toNativeSeparators(filename)),
level=Qgis.Success,
duration=5)
self.setDirty(False)
return True
def testStringToSafeFilename(self):
self.assertEqual(QgsFileUtils.stringToSafeFilename('my FiLe v2.0_new.tif'), 'my FiLe v2.0_new.tif')
self.assertEqual(
QgsFileUtils.stringToSafeFilename('rendered map_final? rev (12-03-1017)_real/\\?%*:|"<>.tif'),
'rendered map_final_ rev (12-03-1017)_real__________.tif')
def testStringToSafeFilename(self):
self.assertEqual(QgsFileUtils.stringToSafeFilename('my FiLe v2.0_new.tif'), 'my FiLe v2.0_new.tif')
self.assertEqual(
QgsFileUtils.stringToSafeFilename('rendered map_final? rev (12-03-1017)_real@#$&*#%&*$!!@$%^&(*(.tif'),
'rendered map_final_ rev _12-03-1017__real____________________.tif')
