def __init__(self, db, sql, parent=None):
self.db = db.connector
t = QTime()
t.start()
c = self.db._execute(None, str(sql))
self._secs = t.elapsed() / 1000.0
del t
self._affectedRows = 0
data = []
header = self.db._get_cursor_columns(c)
if header is None:
header = []
try:
if len(header) > 0:
data = self.db._fetchall(c)
self._affectedRows = c.rowcount
except DbError:
# nothing to fetch!
data = []
header = []
BaseTableModel.__init__(self, header, data, parent)
# commit before closing the cursor to make sure that the changes are stored
self.db._commit()
c.close()
del c
def __init__(self, db, sql, parent=None, layer=None, path=None):
t = QTime()
t.start()
if not layer:
tf = QTemporaryFile()
tf.open()
path = tf.fileName()
tf.close()
df = QgsVirtualLayerDefinition()
df.setFilePath(path)
df.setQuery(sql)
layer = QgsVectorLayer(df.toString(), "vv", "virtual")
self._secs = t.elapsed() / 1000.0
data = []
header = []
if not layer.isValid():
raise DbError(layer.dataProvider().error().summary(), sql)
else:
header = [f.name() for f in layer.fields()]
has_geometry = False
if layer.geometryType() != QgsWkbTypes.NullGeometry:
gn = getQueryGeometryName(path)
if gn:
has_geometry = True
header += [gn]
for f in layer.getFeatures():
a = f.attributes()
if has_geometry:
if f.hasGeometry():
a += [f.geometry().asWkt()]
else:
a += [None]
data += [a]
self._secs = 0
self._affectedRows = len(data)
BaseTableModel.__init__(self, header, data, parent)
def __init__(self, db, sql, parent=None):
# create a virtual layer with non-geometry results
t = QTime()
t.start()
tf = QTemporaryFile()
tf.open()
tmp = tf.fileName()
tf.close()
df = QgsVirtualLayerDefinition()
df.setFilePath(tmp)
df.setQuery(sql)
p = QgsVectorLayer(df.toString(), "vv", "virtual")
self._secs = t.elapsed() / 1000.0
if not p.isValid():
data = []
header = []
raise DbError(p.dataProvider().error().summary(), sql)
else:
header = [f.name() for f in p.fields()]
has_geometry = False
if p.geometryType() != QgsWkbTypes.NullGeometry:
gn = getQueryGeometryName(tmp)
if gn:
has_geometry = True
header += [gn]
data = []
for f in p.getFeatures():
a = f.attributes()
if has_geometry:
if f.hasGeometry():
a += [f.geometry().exportToWkt()]
else:
a += [None]
data += [a]
self._secs = 0
self._affectedRows = len(data)
BaseTableModel.__init__(self, header, data, parent)
def __init__(self, db, sql, parent=None):
# create a virtual layer with non-geometry results
q = QUrl.toPercentEncoding(sql)
t = QTime()
t.start()
tf = QTemporaryFile()
tf.open()
tmp = tf.fileName()
tf.close()
p = QgsVectorLayer("%s?query=%s" % (QUrl.fromLocalFile(tmp).toString(), q), "vv", "virtual")
self._secs = t.elapsed() / 1000.0
if not p.isValid():
data = []
header = []
raise DbError(p.dataProvider().error().summary(), sql)
else:
header = [f.name() for f in p.fields()]
has_geometry = False
if p.geometryType() != QGis.WKBNoGeometry:
gn = getQueryGeometryName(tmp)
if gn:
has_geometry = True
header += [gn]
data = []
for f in p.getFeatures():
a = f.attributes()
if has_geometry:
if f.geometry():
a += [f.geometry().exportToWkt()]
else:
a += [None]
data += [a]
self._secs = 0
self._affectedRows = len(data)
BaseTableModel.__init__(self, header, data, parent)
def testDefaultValues(self):
""" test detection of defaults on OGR layer """
tmpfile = os.path.join(self.basetestpath, 'testDefaults.sqlite')
ds = ogr.GetDriverByName('SQLite').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbPoint, options=['FID=fid'])
lyr.CreateField(ogr.FieldDefn('field1', ogr.OFTInteger))
fld2 = ogr.FieldDefn('field2', ogr.OFTInteger)
fld2.SetDefault('5')
lyr.CreateField(fld2)
fld3 = ogr.FieldDefn('field3', ogr.OFTString)
fld3.SetDefault("'some ''default'")
lyr.CreateField(fld3)
fld4 = ogr.FieldDefn('field4', ogr.OFTDate)
fld4.SetDefault("CURRENT_DATE")
lyr.CreateField(fld4)
fld5 = ogr.FieldDefn('field5', ogr.OFTTime)
fld5.SetDefault("CURRENT_TIME")
lyr.CreateField(fld5)
fld6 = ogr.FieldDefn('field6', ogr.OFTDateTime)
fld6.SetDefault("CURRENT_TIMESTAMP")
lyr.CreateField(fld6)
ds = None
vl = QgsVectorLayer('{}'.format(tmpfile), 'test', 'ogr')
self.assertTrue(vl.isValid())
# test some bad indexes
self.assertFalse(vl.dataProvider().defaultValue(-1))
self.assertFalse(vl.dataProvider().defaultValue(1001))
# test default
self.assertEqual(vl.dataProvider().defaultValue(1), NULL)
self.assertEqual(vl.dataProvider().defaultValue(2), 5)
self.assertEqual(vl.dataProvider().defaultValue(3), "some 'default")
self.assertEqual(vl.dataProvider().defaultValue(4), QDate.currentDate())
# time may pass, so we allow 1 second difference here
self.assertTrue(vl.dataProvider().defaultValue(5).secsTo(QTime.currentTime()) < 1)
self.assertTrue(vl.dataProvider().defaultValue(6).secsTo(QDateTime.currentDateTime()) < 1)
def testDateTime(self):
""" Test calculation of aggregates on date/datetime fields"""
layer = QgsVectorLayer("Point?field=flddate:date&field=flddatetime:datetime", "layer", "memory")
pr = layer.dataProvider()
# must be same length:
datetime_values = [QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2011, 1, 5), QTime(15, 3, 1)),
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1)),
QDateTime(),
QDateTime(QDate(1998, 1, 2), QTime(1, 10, 54)),
QDateTime(),
QDateTime(QDate(2011, 1, 5), QTime(11, 10, 54))]
date_values = [QDate(2015, 3, 4),
QDate(2015, 3, 4),
QDate(2019, 12, 28),
QDate(),
QDate(1998, 1, 2),
QDate(),
QDate(2011, 1, 5),
QDate(2011, 1, 5),
QDate(2011, 1, 5)]
self.assertEqual(len(datetime_values), len(date_values))
features = []
for i in range(len(datetime_values)):
f = QgsFeature()
f.setFields(layer.fields())
f.setAttributes([date_values[i], datetime_values[i]])
features.append(f)
assert pr.addFeatures(features)
tests = [[QgsAggregateCalculator.Count, 'flddatetime', 9],
[QgsAggregateCalculator.Count, 'flddate', 9],
[QgsAggregateCalculator.CountDistinct, 'flddatetime', 6],
[QgsAggregateCalculator.CountDistinct, 'flddate', 5],
[QgsAggregateCalculator.CountMissing, 'flddatetime', 2],
[QgsAggregateCalculator.CountMissing, 'flddate', 2],
[QgsAggregateCalculator.Min, 'flddatetime', QDateTime(QDate(1998, 1, 2), QTime(1, 10, 54))],
[QgsAggregateCalculator.Min, 'flddate', QDateTime(QDate(1998, 1, 2), QTime(0, 0, 0))],
[QgsAggregateCalculator.Max, 'flddatetime', QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1))],
[QgsAggregateCalculator.Max, 'flddate', QDateTime(QDate(2019, 12, 28), QTime(0, 0, 0))],
[QgsAggregateCalculator.Range, 'flddatetime', QgsInterval(693871147)],
[QgsAggregateCalculator.Range, 'flddate', QgsInterval(693792000)],
]
agg = QgsAggregateCalculator(layer)
for t in tests:
val, ok = agg.calculate(t[0], t[1])
self.assertTrue(ok)
self.assertEqual(val, t[2])
# bad tests - the following stats should not be calculatable for string fields
for t in [QgsAggregateCalculator.Sum,
QgsAggregateCalculator.Mean,
QgsAggregateCalculator.Median,
QgsAggregateCalculator.StDev,
QgsAggregateCalculator.StDevSample,
QgsAggregateCalculator.Minority,
QgsAggregateCalculator.Majority,
QgsAggregateCalculator.FirstQuartile,
QgsAggregateCalculator.ThirdQuartile,
QgsAggregateCalculator.InterQuartileRange,
QgsAggregateCalculator.StringMinimumLength,
QgsAggregateCalculator.StringMaximumLength,
]:
val, ok = agg.calculate(t, 'flddatetime')
self.assertFalse(ok)
def testExpression(self):
""" test aggregate calculation using an expression """
# numeric
layer = QgsVectorLayer("Point?field=fldint:integer", "layer", "memory")
pr = layer.dataProvider()
int_values = [4, 2, 3, 2, 5, None, 8]
features = []
for v in int_values:
f = QgsFeature()
f.setFields(layer.fields())
f.setAttributes([v])
features.append(f)
assert pr.addFeatures(features)
# int
agg = QgsAggregateCalculator(layer)
val, ok = agg.calculate(QgsAggregateCalculator.Sum, 'fldint * 2')
self.assertTrue(ok)
self.assertEqual(val, 48)
# double
val, ok = agg.calculate(QgsAggregateCalculator.Sum, 'fldint * 1.5')
self.assertTrue(ok)
self.assertEqual(val, 36)
# datetime
val, ok = agg.calculate(QgsAggregateCalculator.Max, "to_date('2012-05-04') + to_interval( fldint || ' day' )")
self.assertTrue(ok)
self.assertEqual(val, QDateTime(QDate(2012, 5, 12), QTime(0, 0, 0)))
# date
val, ok = agg.calculate(QgsAggregateCalculator.Min, "to_date(to_date('2012-05-04') + to_interval( fldint || ' day' ))")
self.assertTrue(ok)
self.assertEqual(val, QDateTime(QDate(2012, 5, 6), QTime(0, 0, 0)))
# string
val, ok = agg.calculate(QgsAggregateCalculator.Max, "fldint || ' oranges'")
self.assertTrue(ok)
self.assertEqual(val, '8 oranges')
# geometry
val, ok = agg.calculate(QgsAggregateCalculator.GeometryCollect, "make_point( coalesce(fldint,0), 2 )")
self.assertTrue(ok)
self.assertTrue(val.exportToWkt(), 'MultiPoint((4 2, 2 2, 3 2, 2 2,5 2, 0 2,8 2))')
# try a bad expression
val, ok = agg.calculate(QgsAggregateCalculator.Max, "not_a_field || ' oranges'")
self.assertFalse(ok)
val, ok = agg.calculate(QgsAggregateCalculator.Max, "5+")
self.assertFalse(ok)
# test expression context
# check default context first
# should have layer variables:
val, ok = agg.calculate(QgsAggregateCalculator.Min, "@layer_name")
self.assertTrue(ok)
self.assertEqual(val, 'layer')
# but not custom variables:
val, ok = agg.calculate(QgsAggregateCalculator.Min, "@my_var")
self.assertTrue(ok)
self.assertEqual(val, NULL)
# test with manual expression context
scope = QgsExpressionContextScope()
scope.setVariable('my_var', 5)
context = QgsExpressionContext()
context.appendScope(scope)
val, ok = agg.calculate(QgsAggregateCalculator.Min, "@my_var", context)
self.assertTrue(ok)
self.assertEqual(val, 5)
def createTestMetadata(self):
"""
Returns a standard metadata which can be tested with checkExpectedMetadata
"""
m = QgsProjectMetadata()
m.setIdentifier('1234')
m.setParentIdentifier('xyz')
m.setLanguage('en-CA')
m.setType('project')
m.setTitle('roads')
m.setAbstract('my roads')
m.setHistory(['history a', 'history b'])
m.setKeywords({
'GEMET': ['kw1', 'kw2'],
'gmd:topicCategory': ['natural'],
})
c = QgsAbstractMetadataBase.Contact()
c.name = 'John Smith'
c.organization = 'ACME'
c.position = 'staff'
c.voice = '1500 515 555'
c.fax = 'xx.xxx.xxx.xxxx'
c.email = '*****@*****.**'
c.role = 'pointOfContact'
address = QgsAbstractMetadataBase.Address()
address.type = 'postal'
address.address = '123 Main Street'
address.city = 'anycity'
address.administrativeArea = 'anyprovince'
address.postalCode = '90210'
address.country = 'Canada'
c.addresses = [address]
m.setContacts([c])
l = QgsAbstractMetadataBase.Link()
l.name = 'geonode:roads'
l.type = 'OGC:WMS'
l.description = 'my GeoNode road layer'
l.url = 'http://example.org/wms'
l2 = QgsAbstractMetadataBase.Link()
l2.name = 'geonode:roads'
l2.type = 'OGC:WFS'
l2.description = 'my GeoNode road layer'
l2.url = 'http://example.org/wfs'
l3 = QgsAbstractMetadataBase.Link()
l3.name = 'roads'
l3.type = 'WWW:LINK'
l3.description = 'full dataset download'
l3.url = 'http://example.org/roads.tgz'
l3.format = 'ESRI Shapefile'
l3.mimeType = 'application/gzip'
l3.size = '283676'
m.setLinks([l, l2, l3])
m.setAuthor('my author')
m.setCreationDateTime(QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47)))
return m
def testCreateExpression(self):
""" Test creating an expression using the widget"""
layer = QgsVectorLayer(
"Point?field=date:date&field=time:time&field=datetime:datetime",
"test", "memory")
w = QgsDateTimeSearchWidgetWrapper(layer, 0)
config = {"field_format": 'yyyy-MM-dd', "display_format": 'yyyy-MM-dd'}
w.setConfig(config)
c = w.widget()
# first check with date field type
c.setDateTime(QDateTime(QDate(2013, 4, 5), QTime()))
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNull),
'"date" IS NULL')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNotNull),
'"date" IS NOT NULL')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo),
'"date"=\'2013-04-05\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo),
'"date"<>\'2013-04-05\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.GreaterThan),
'"date">\'2013-04-05\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.LessThan),
'"date"<\'2013-04-05\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.GreaterThanOrEqualTo),
'"date">=\'2013-04-05\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.LessThanOrEqualTo),
'"date"<=\'2013-04-05\'')
# time field type
w = QgsDateTimeSearchWidgetWrapper(layer, 1)
config = {"field_format": 'HH:mm:ss', "display_format": 'HH:mm:ss'}
w.setConfig(config)
c = w.widget()
c.setDateTime(QDateTime(QDate(2013, 4, 5), QTime(13, 14, 15)))
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNull),
'"time" IS NULL')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNotNull),
'"time" IS NOT NULL')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo),
'"time"=\'13:14:15\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo),
'"time"<>\'13:14:15\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.GreaterThan),
'"time">\'13:14:15\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.LessThan),
'"time"<\'13:14:15\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.GreaterThanOrEqualTo),
'"time">=\'13:14:15\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.LessThanOrEqualTo),
'"time"<=\'13:14:15\'')
# datetime field type
w = QgsDateTimeSearchWidgetWrapper(layer, 2)
config = {
"field_format": 'yyyy-MM-dd HH:mm:ss',
"display_format": 'yyyy-MM-dd HH:mm:ss'
}
w.setConfig(config)
c = w.widget()
c.setDateTime(QDateTime(QDate(2013, 4, 5), QTime(13, 14, 15)))
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNull),
'"datetime" IS NULL')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNotNull),
'"datetime" IS NOT NULL')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo),
'"datetime"=\'2013-04-05 13:14:15\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo),
'"datetime"<>\'2013-04-05 13:14:15\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.GreaterThan),
'"datetime">\'2013-04-05 13:14:15\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.LessThan),
'"datetime"<\'2013-04-05 13:14:15\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.GreaterThanOrEqualTo),
'"datetime">=\'2013-04-05 13:14:15\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.LessThanOrEqualTo),
'"datetime"<=\'2013-04-05 13:14:15\'')
def testExportToSvg(self):
md = QgsProject.instance().metadata()
md.setTitle('proj title')
md.setAuthor('proj author')
md.setCreationDateTime(QDateTime(QDate(2011, 5, 3), QTime(9, 4, 5), QTimeZone(36000)))
md.setIdentifier('proj identifier')
md.setAbstract('proj abstract')
md.setKeywords({'kw': ['kw1', 'kw2']})
QgsProject.instance().setMetadata(md)
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add a second page
page2 = QgsLayoutItemPage(l)
page2.setPageSize('A5')
l.pageCollection().addPage(page2)
# add some items
item1 = QgsLayoutItemShape(l)
item1.attemptSetSceneRect(QRectF(10, 20, 100, 150))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.green)
fill.setStrokeStyle(Qt.NoPen)
item1.setSymbol(fill_symbol)
l.addItem(item1)
item2 = QgsLayoutItemShape(l)
item2.attemptSetSceneRect(QRectF(10, 20, 100, 150))
item2.attemptMove(QgsLayoutPoint(10, 20), page=1)
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.cyan)
fill.setStrokeStyle(Qt.NoPen)
item2.setSymbol(fill_symbol)
l.addItem(item2)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.SvgExportSettings()
settings.dpi = 80
settings.forceVectorOutput = False
settings.exportMetadata = True
svg_file_path = os.path.join(self.basetestpath, 'test_exporttosvgdpi.svg')
svg_file_path_2 = os.path.join(self.basetestpath, 'test_exporttosvgdpi_2.svg')
self.assertEqual(exporter.exportToSvg(svg_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(os.path.exists(svg_file_path))
self.assertTrue(os.path.exists(svg_file_path_2))
# metadata
def checkMetadata(f, expected):
# ideally we'd check the path too - but that's very complex given that
# the output from Qt svg generator isn't valid XML, and no Python standard library
# xml parser handles invalid xml...
self.assertEqual('proj title' in open(f).read(), expected)
self.assertEqual('proj author' in open(f).read(), expected)
self.assertEqual('proj identifier' in open(f).read(), expected)
self.assertEqual('2011-05-03' in open(f).read(), expected)
self.assertEqual('proj abstract' in open(f).read(), expected)
self.assertEqual('kw1' in open(f).read(), expected)
self.assertEqual('kw2' in open(f).read(), expected)
for f in [svg_file_path, svg_file_path_2]:
checkMetadata(f, True)
rendered_page_1 = os.path.join(self.basetestpath, 'test_exporttosvgdpi.png')
svgToPng(svg_file_path, rendered_page_1, width=936)
rendered_page_2 = os.path.join(self.basetestpath, 'test_exporttosvgdpi2.png')
svgToPng(svg_file_path_2, rendered_page_2, width=467)
self.assertTrue(self.checkImage('exporttosvgdpi_page1', 'exporttopdfdpi_page1', rendered_page_1, size_tolerance=1))
self.assertTrue(self.checkImage('exporttosvgdpi_page2', 'exporttopdfdpi_page2', rendered_page_2, size_tolerance=1))
# no metadata
settings.exportMetadata = False
self.assertEqual(exporter.exportToSvg(svg_file_path, settings), QgsLayoutExporter.Success)
for f in [svg_file_path, svg_file_path_2]:
checkMetadata(f, False)
# layered
settings.exportAsLayers = True
settings.exportMetadata = True
svg_file_path = os.path.join(self.basetestpath, 'test_exporttosvglayered.svg')
svg_file_path_2 = os.path.join(self.basetestpath, 'test_exporttosvglayered_2.svg')
self.assertEqual(exporter.exportToSvg(svg_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(os.path.exists(svg_file_path))
self.assertTrue(os.path.exists(svg_file_path_2))
rendered_page_1 = os.path.join(self.basetestpath, 'test_exporttosvglayered.png')
svgToPng(svg_file_path, rendered_page_1, width=936)
rendered_page_2 = os.path.join(self.basetestpath, 'test_exporttosvglayered2.png')
svgToPng(svg_file_path_2, rendered_page_2, width=467)
self.assertTrue(self.checkImage('exporttosvglayered_page1', 'exporttopdfdpi_page1', rendered_page_1, size_tolerance=1))
self.assertTrue(self.checkImage('exporttosvglayered_page2', 'exporttopdfdpi_page2', rendered_page_2, size_tolerance=1))
for f in [svg_file_path, svg_file_path_2]:
checkMetadata(f, True)
# layered no metadata
settings.exportAsLayers = True
settings.exportMetadata = False
self.assertEqual(exporter.exportToSvg(svg_file_path, settings), QgsLayoutExporter.Success)
for f in [svg_file_path, svg_file_path_2]:
checkMetadata(f, False)
def testDateTimeWriteShapefile(self):
"""Check writing date and time fields to an ESRI shapefile."""
ml = QgsVectorLayer(
('Point?crs=epsg:4326&field=id:int&'
'field=date_f:date&field=time_f:time&field=dt_f:datetime'),
'test', 'memory')
self.assertTrue(ml.isValid())
provider = ml.dataProvider()
self.assertIsNotNone(provider)
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPointXY(QgsPointXY(10, 10)))
ft.setAttributes([
1,
QDate(2014, 3, 5),
QTime(13, 45, 22),
QDateTime(QDate(2014, 3, 5), QTime(13, 45, 22))
])
res, features = provider.addFeatures([ft])
self.assertTrue(res)
self.assertTrue(features)
dest_file_name = os.path.join(str(QDir.tempPath()), 'datetime.shp')
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result, error_message = QgsVectorFileWriter.writeAsVectorFormat(
ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile')
self.assertEqual(write_result, QgsVectorFileWriter.NoError,
error_message)
# Open result and check
created_layer = QgsVectorLayer('{}|layerid=0'.format(dest_file_name),
'test', 'ogr')
fields = created_layer.dataProvider().fields()
self.assertEqual(
fields.at(fields.indexFromName('date_f')).type(), QVariant.Date)
# shapefiles do not support time types, result should be string
self.assertEqual(
fields.at(fields.indexFromName('time_f')).type(), QVariant.String)
# shapefiles do not support datetime types, result should be string
self.assertEqual(
fields.at(fields.indexFromName('dt_f')).type(), QVariant.String)
f = next(created_layer.getFeatures(QgsFeatureRequest()))
date_idx = created_layer.fields().lookupField('date_f')
self.assertIsInstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5))
time_idx = created_layer.fields().lookupField('time_f')
# shapefiles do not support time types
self.assertIsInstance(f.attributes()[time_idx], str)
self.assertEqual(f.attributes()[time_idx], '13:45:22')
# shapefiles do not support datetime types
datetime_idx = created_layer.fields().lookupField('dt_f')
self.assertIsInstance(f.attributes()[datetime_idx], str)
self.assertEqual(
f.attributes()[datetime_idx],
QDateTime(QDate(2014, 3, 5),
QTime(13, 45, 22)).toString("yyyy/MM/dd hh:mm:ss.zzz"))
def testFixedRangeMode(self):
props = QgsVectorLayerTemporalProperties(enabled=True)
props.setMode(QgsVectorLayerTemporalProperties.ModeFixedTemporalRange)
props.setFixedTemporalRange(
QgsDateTimeRange(QDateTime(QDate(2019, 3, 4), QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10))))
self.assertTrue(
props.isVisibleInTemporalRange(
QgsDateTimeRange(
QDateTime(QDate(2019, 3, 4), QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)))))
self.assertTrue(
props.isVisibleInTemporalRange(
QgsDateTimeRange(
QDateTime(QDate(2019, 1, 4), QTime(11, 12, 13)),
QDateTime(QDate(2019, 5, 6), QTime(8, 9, 10)))))
self.assertTrue(
props.isVisibleInTemporalRange(
QgsDateTimeRange(
QDateTime(QDate(2020, 3, 4), QTime(11, 12, 13)),
QDateTime(QDate(2019, 9, 6), QTime(8, 9, 10)))))
self.assertFalse(
props.isVisibleInTemporalRange(
QgsDateTimeRange(
QDateTime(QDate(2120, 3, 4), QTime(11, 12, 13)),
QDateTime(QDate(2121, 9, 6), QTime(8, 9, 10)))))
self.assertFalse(
props.isVisibleInTemporalRange(
QgsDateTimeRange(
QDateTime(QDate(1920, 3, 4), QTime(11, 12, 13)),
QDateTime(QDate(1921, 9, 6), QTime(8, 9, 10)))))
layer = QgsVectorLayer(
"Point?field=fldtxt:string&field=fldint:integer&field=start_field:datetime",
"test", "memory")
range = QgsDateTimeRange(
QDateTime(QDate(2019, 3, 4), QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)))
# ALWAYS must be empty for ModeFixedTemporalRange
self.assertFalse(props.createFilterString(layer, range))
def checkExpectedMetadata(self, m):
"""
Checks that a metadata object matches that returned by createTestMetadata
"""
self.assertEqual(m.identifier(), '1234')
self.assertEqual(m.parentIdentifier(), 'xyz')
self.assertEqual(m.language(), 'en-CA')
self.assertEqual(m.type(), 'dataset')
self.assertEqual(m.title(), 'roads')
self.assertEqual(m.abstract(), 'my roads')
self.assertEqual(m.fees(), 'None')
self.assertEqual(m.constraints()[0].constraint, 'None')
self.assertEqual(m.constraints()[0].type, 'access')
self.assertEqual(m.rights(), ['Copyright foo 2017'])
self.assertEqual(m.licenses(), ['WTFPL'])
self.assertEqual(m.history(), ['history a', 'history b'])
self.assertEqual(m.encoding(), 'utf-8')
self.assertEqual(m.keywords(), {
'GEMET': ['kw1', 'kw2'],
'gmd:topicCategory': ['natural']
})
self.assertEqual(m.crs().authid(), 'EPSG:4326')
extent = m.extent().spatialExtents()[0]
self.assertEqual(extent.extentCrs.authid(), 'EPSG:4326')
self.assertEqual(extent.bounds.xMinimum(), -180.0)
self.assertEqual(extent.bounds.yMinimum(), -90.0)
self.assertEqual(extent.bounds.xMaximum(), 180.0)
self.assertEqual(extent.bounds.yMaximum(), 90.0)
self.assertEqual(m.extent().temporalExtents()[0].begin(),
QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47)))
self.assertTrue(m.extent().temporalExtents()[0].isInstant())
self.assertFalse(m.extent().temporalExtents()[1].isInstant())
self.assertEqual(m.extent().temporalExtents()[1].end(),
QDateTime(QDate(2020, 12, 17), QTime(9, 30, 47)))
self.assertEqual(m.contacts()[0].name, 'John Smith')
self.assertEqual(m.contacts()[0].organization, 'ACME')
self.assertEqual(m.contacts()[0].position, 'staff')
self.assertEqual(m.contacts()[0].voice, '1500 515 555')
self.assertEqual(m.contacts()[0].fax, 'xx.xxx.xxx.xxxx')
self.assertEqual(m.contacts()[0].email, '*****@*****.**')
self.assertEqual(m.contacts()[0].role, 'pointOfContact')
self.assertEqual(m.contacts()[0].addresses[0].type, 'postal')
self.assertEqual(m.contacts()[0].addresses[0].address,
'123 Main Street')
self.assertEqual(m.contacts()[0].addresses[0].city, 'anycity')
self.assertEqual(m.contacts()[0].addresses[0].administrativeArea,
'anyprovince')
self.assertEqual(m.contacts()[0].addresses[0].postalCode, '90210')
self.assertEqual(m.contacts()[0].addresses[0].country, 'Canada')
self.assertEqual(m.links()[0].name, 'geonode:roads')
self.assertEqual(m.links()[0].type, 'OGC:WMS')
self.assertEqual(m.links()[0].description, 'my GeoNode road layer')
self.assertEqual(m.links()[0].url, 'http://example.org/wms')
self.assertEqual(m.links()[1].name, 'geonode:roads')
self.assertEqual(m.links()[1].type, 'OGC:WFS')
self.assertEqual(m.links()[1].description, 'my GeoNode road layer')
self.assertEqual(m.links()[1].url, 'http://example.org/wfs')
self.assertEqual(m.links()[2].name, 'roads')
self.assertEqual(m.links()[2].type, 'WWW:LINK')
self.assertEqual(m.links()[2].description, 'full dataset download')
self.assertEqual(m.links()[2].url, 'http://example.org/roads.tgz')
self.assertEqual(m.links()[2].format, 'ESRI Shapefile')
self.assertEqual(m.links()[2].mimeType, 'application/gzip')
self.assertEqual(m.links()[2].size, '283676')
def testStats(self):
# we test twice, once with values added as a list and once using values
# added one-at-a-time
dates = [
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2011, 1, 5), QTime(15, 3, 1)),
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1)),
QDateTime(),
QDateTime(QDate(1998, 1, 2), QTime(1, 10, 54)),
QDateTime(),
QDateTime(QDate(2011, 1, 5), QTime(11, 10, 54))
]
s = QgsDateTimeStatisticalSummary()
self.assertEqual(s.statistics(), QgsDateTimeStatisticalSummary.All)
s.calculate(dates)
s2 = QgsDateTimeStatisticalSummary()
for d in dates:
s2.addValue(d)
s2.finalize()
self.assertEqual(s.count(), 9)
self.assertEqual(s2.count(), 9)
self.assertEqual(s.countDistinct(), 6)
self.assertEqual(s2.countDistinct(), 6)
self.assertEqual(
set(s.distinctValues()),
set([
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2011, 1, 5), QTime(15, 3, 1)),
QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1)),
QDateTime(),
QDateTime(QDate(1998, 1, 2), QTime(1, 10, 54)),
QDateTime(QDate(2011, 1, 5), QTime(11, 10, 54))
]))
self.assertEqual(s2.distinctValues(), s.distinctValues())
self.assertEqual(s.countMissing(), 2)
self.assertEqual(s2.countMissing(), 2)
self.assertEqual(s.min(), QDateTime(QDate(1998, 1, 2),
QTime(1, 10, 54)))
self.assertEqual(s2.min(),
QDateTime(QDate(1998, 1, 2), QTime(1, 10, 54)))
self.assertEqual(s.max(),
QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1)))
self.assertEqual(s2.max(),
QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1)))
self.assertEqual(s.range(), QgsInterval(693871147))
self.assertEqual(s2.range(), QgsInterval(693871147))
def testIndividualStats(self):
# tests calculation of statistics one at a time, to make sure statistic calculations are not
# dependent on each other
tests = [
{
'stat': QgsDateTimeStatisticalSummary.Count,
'expected': 9
},
{
'stat': QgsDateTimeStatisticalSummary.CountDistinct,
'expected': 6
},
{
'stat': QgsDateTimeStatisticalSummary.CountMissing,
'expected': 2
},
{
'stat': QgsDateTimeStatisticalSummary.Min,
'expected': QDateTime(QDate(1998, 1, 2), QTime(1, 10, 54))
},
{
'stat': QgsDateTimeStatisticalSummary.Max,
'expected': QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1))
},
{
'stat': QgsDateTimeStatisticalSummary.Range,
'expected': QgsInterval(693871147)
},
]
# we test twice, once with values added as a list and once using values
# added one-at-a-time
s = QgsDateTimeStatisticalSummary()
s3 = QgsDateTimeStatisticalSummary()
for t in tests:
# test constructor
s2 = QgsDateTimeStatisticalSummary(t['stat'])
self.assertEqual(s2.statistics(), t['stat'])
s.setStatistics(t['stat'])
self.assertEqual(s.statistics(), t['stat'])
s3.setStatistics(t['stat'])
dates = [
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2011, 1, 5), QTime(15, 3, 1)),
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1)),
QDateTime(),
QDateTime(QDate(1998, 1, 2), QTime(1, 10, 54)),
QDateTime(),
QDateTime(QDate(2011, 1, 5), QTime(11, 10, 54))
]
s.calculate(dates)
s3.reset()
for d in dates:
s3.addValue(d)
s3.finalize()
self.assertEqual(s.statistic(t['stat']), t['expected'])
self.assertEqual(s3.statistic(t['stat']), t['expected'])
# display name
self.assertTrue(
len(QgsDateTimeStatisticalSummary.displayName(t['stat'])) > 0)
def testTimes(self):
""" test with time values """
s = QgsDateTimeStatisticalSummary()
self.assertEqual(s.statistics(), QgsDateTimeStatisticalSummary.All)
s.calculate([
QTime(11, 3, 4),
QTime(15, 3, 4),
QTime(19, 12, 28),
QTime(),
QTime(8, 1, 2),
QTime(),
QTime(19, 12, 28)
])
self.assertEqual(s.count(), 7)
self.assertEqual(s.countDistinct(), 5)
self.assertEqual(s.countMissing(), 2)
self.assertEqual(s.min().time(), QTime(8, 1, 2))
self.assertEqual(s.max().time(), QTime(19, 12, 28))
self.assertEqual(s.statistic(QgsDateTimeStatisticalSummary.Min),
QTime(8, 1, 2))
self.assertEqual(s.statistic(QgsDateTimeStatisticalSummary.Max),
QTime(19, 12, 28))
self.assertEqual(s.range(), QgsInterval(40286))
def testVariantStats(self):
""" test with non-datetime values """
s = QgsDateTimeStatisticalSummary()
self.assertEqual(s.statistics(), QgsDateTimeStatisticalSummary.All)
s.calculate([
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)), 'asdasd',
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)), 34,
QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1)),
QDateTime(),
QDateTime(QDate(1998, 1, 2), QTime(1, 10, 54)),
QDateTime(),
QDateTime(QDate(2011, 1, 5), QTime(11, 10, 54))
])
self.assertEqual(s.count(), 9)
self.assertEqual(
set(s.distinctValues()),
set([
QDateTime(QDate(2015, 3, 4), QTime(11, 10, 54)),
QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1)),
QDateTime(QDate(1998, 1, 2), QTime(1, 10, 54)),
QDateTime(QDate(2011, 1, 5), QTime(11, 10, 54)),
QDateTime()
]))
self.assertEqual(s.countMissing(), 4)
self.assertEqual(s.min(), QDateTime(QDate(1998, 1, 2),
QTime(1, 10, 54)))
self.assertEqual(s.max(),
QDateTime(QDate(2019, 12, 28), QTime(23, 10, 1)))
self.assertEqual(s.range(), QgsInterval(693871147))
def testLayerMode(self):
"""
Create a fully populated QgsLayerMetadata object, then set it to the widget and re-read back
the generated metadata to ensure that no content is lost.
"""
w = QgsMetadataWidget()
m = QgsLayerMetadata()
m.setIdentifier('1234')
m.setParentIdentifier('xyz')
m.setLanguage('en-CA')
m.setType('dataset')
m.setTitle('roads')
m.setAbstract('my roads')
m.setFees('None')
m.setConstraints([QgsLayerMetadata.Constraint('None', 'access')])
m.setRights(['Copyright foo 2017'])
m.setLicenses(['WTFPL'])
m.setHistory(['history a', 'history b'])
m.setKeywords({
'GEMET': ['kw1', 'kw2'],
'gmd:topicCategory': ['natural'],
})
#m.setEncoding('utf-8')
m.setCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4326'))
e = QgsLayerMetadata.Extent()
se = QgsLayerMetadata.SpatialExtent()
se.extentCrs = QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4326')
se.bounds = QgsBox3d(-180, -90, 0, 180, 90, 0)
e.setSpatialExtents([se])
dates = [
QgsDateTimeRange(QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47)),
QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47)))
]
e.setTemporalExtents(dates)
m.setExtent(e)
c = QgsLayerMetadata.Contact()
c.name = 'John Smith'
c.organization = 'ACME'
c.position = 'staff'
c.voice = '1500 515 555'
c.fax = 'xx.xxx.xxx.xxxx'
c.email = '*****@*****.**'
c.role = 'pointOfContact'
address = QgsLayerMetadata.Address()
address.type = 'postal'
address.address = '123 Main Street'
address.city = 'anycity'
address.administrativeArea = 'anyprovince'
address.postalCode = '90210'
address.country = 'Canada'
c.addresses = [address]
m.setContacts([c])
l = QgsLayerMetadata.Link()
l.name = 'geonode:roads'
l.type = 'OGC:WMS'
l.description = 'my GeoNode road layer'
l.url = 'http://example.org/wms'
l2 = QgsLayerMetadata.Link()
l2.name = 'geonode:roads'
l2.type = 'OGC:WFS'
l2.description = 'my GeoNode road layer'
l2.url = 'http://example.org/wfs'
l3 = QgsLayerMetadata.Link()
l3.name = 'roads'
l3.type = 'WWW:LINK'
l3.description = 'full dataset download'
l3.url = 'http://example.org/roads.tgz'
l3.format = 'ESRI Shapefile'
l3.mimeType = 'application/gzip'
l3.size = '283676'
m.setLinks([l, l2, l3])
# set widget metadata
w.setMetadata(m)
self.assertEqual(w.mode(), QgsMetadataWidget.LayerMetadata)
m = w.metadata()
self.assertIsInstance(m, QgsLayerMetadata)
self.assertEqual(m.identifier(), '1234')
self.assertEqual(m.parentIdentifier(), 'xyz')
self.assertEqual(m.language(), 'en-CA')
self.assertEqual(m.type(), 'dataset')
self.assertEqual(m.title(), 'roads')
self.assertEqual(m.abstract(), 'my roads')
self.assertEqual(m.fees(), 'None')
self.assertEqual(m.constraints()[0].constraint, 'None')
self.assertEqual(m.constraints()[0].type, 'access')
self.assertEqual(m.rights(), ['Copyright foo 2017'])
self.assertEqual(m.licenses(), ['WTFPL'])
self.assertEqual(m.history(), ['history a', 'history b'])
#self.assertEqual(m.encoding(), 'utf-8')
self.assertEqual(m.keywords(), {
'GEMET': ['kw1', 'kw2'],
'gmd:topicCategory': ['natural']
})
self.assertEqual(m.crs().authid(), 'EPSG:4326')
extent = m.extent().spatialExtents()[0]
self.assertEqual(extent.extentCrs.authid(), 'EPSG:4326')
self.assertEqual(extent.bounds.xMinimum(), -180.0)
self.assertEqual(extent.bounds.yMinimum(), -90.0)
self.assertEqual(extent.bounds.xMaximum(), 180.0)
self.assertEqual(extent.bounds.yMaximum(), 90.0)
self.assertEqual(m.extent().temporalExtents()[0].begin(),
QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47)))
self.assertTrue(m.extent().temporalExtents()[0].isInstant())
self.assertEqual(m.contacts()[0].name, 'John Smith')
self.assertEqual(m.contacts()[0].organization, 'ACME')
self.assertEqual(m.contacts()[0].position, 'staff')
self.assertEqual(m.contacts()[0].voice, '1500 515 555')
self.assertEqual(m.contacts()[0].fax, 'xx.xxx.xxx.xxxx')
self.assertEqual(m.contacts()[0].email, '*****@*****.**')
self.assertEqual(m.contacts()[0].role, 'pointOfContact')
self.assertEqual(m.contacts()[0].addresses[0].type, 'postal')
self.assertEqual(m.contacts()[0].addresses[0].address,
'123 Main Street')
self.assertEqual(m.contacts()[0].addresses[0].city, 'anycity')
self.assertEqual(m.contacts()[0].addresses[0].administrativeArea,
'anyprovince')
self.assertEqual(m.contacts()[0].addresses[0].postalCode, '90210')
self.assertEqual(m.contacts()[0].addresses[0].country, 'Canada')
self.assertEqual(m.links()[0].name, 'geonode:roads')
self.assertEqual(m.links()[0].type, 'OGC:WMS')
self.assertEqual(m.links()[0].description, 'my GeoNode road layer')
self.assertEqual(m.links()[0].url, 'http://example.org/wms')
self.assertEqual(m.links()[1].name, 'geonode:roads')
self.assertEqual(m.links()[1].type, 'OGC:WFS')
self.assertEqual(m.links()[1].description, 'my GeoNode road layer')
self.assertEqual(m.links()[1].url, 'http://example.org/wfs')
self.assertEqual(m.links()[2].name, 'roads')
self.assertEqual(m.links()[2].type, 'WWW:LINK')
self.assertEqual(m.links()[2].description, 'full dataset download')
self.assertEqual(m.links()[2].url, 'http://example.org/roads.tgz')
self.assertEqual(m.links()[2].format, 'ESRI Shapefile')
self.assertEqual(m.links()[2].mimeType, 'application/gzip')
self.assertEqual(m.links()[2].size, '283676')
def testProjectMode(self):
"""
Create a fully populated QgsProjectMetadata object, then set it to the widget and re-read back
the generated metadata to ensure that no content is lost.
"""
w = QgsMetadataWidget()
m = QgsProjectMetadata()
m.setIdentifier('1234')
m.setParentIdentifier('xyz')
m.setLanguage('en-CA')
m.setType('project')
m.setTitle('roads')
m.setAbstract('my roads')
m.setHistory(['history a', 'history b'])
m.setKeywords({
'GEMET': ['kw1', 'kw2'],
'gmd:topicCategory': ['natural'],
})
c = QgsAbstractMetadataBase.Contact()
c.name = 'John Smith'
c.organization = 'ACME'
c.position = 'staff'
c.voice = '1500 515 555'
c.fax = 'xx.xxx.xxx.xxxx'
c.email = '*****@*****.**'
c.role = 'pointOfContact'
address = QgsAbstractMetadataBase.Address()
address.type = 'postal'
address.address = '123 Main Street'
address.city = 'anycity'
address.administrativeArea = 'anyprovince'
address.postalCode = '90210'
address.country = 'Canada'
c.addresses = [address]
m.setContacts([c])
l = QgsAbstractMetadataBase.Link()
l.name = 'geonode:roads'
l.type = 'OGC:WMS'
l.description = 'my GeoNode road layer'
l.url = 'http://example.org/wms'
l2 = QgsAbstractMetadataBase.Link()
l2.name = 'geonode:roads'
l2.type = 'OGC:WFS'
l2.description = 'my GeoNode road layer'
l2.url = 'http://example.org/wfs'
l3 = QgsAbstractMetadataBase.Link()
l3.name = 'roads'
l3.type = 'WWW:LINK'
l3.description = 'full dataset download'
l3.url = 'http://example.org/roads.tgz'
l3.format = 'ESRI Shapefile'
l3.mimeType = 'application/gzip'
l3.size = '283676'
m.setLinks([l, l2, l3])
m.setAuthor('my author')
m.setCreationDateTime(QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47)))
# set widget metadata
w.setMetadata(m)
self.assertEqual(w.mode(), QgsMetadataWidget.ProjectMetadata)
m = w.metadata()
self.assertIsInstance(m, QgsProjectMetadata)
self.assertEqual(m.identifier(), '1234')
self.assertEqual(m.parentIdentifier(), 'xyz')
self.assertEqual(m.language(), 'en-CA')
self.assertEqual(m.type(), 'project')
self.assertEqual(m.title(), 'roads')
self.assertEqual(m.abstract(), 'my roads')
self.assertEqual(m.history(), ['history a', 'history b'])
self.assertEqual(m.keywords(), {
'GEMET': ['kw1', 'kw2'],
'gmd:topicCategory': ['natural']
})
self.assertEqual(m.contacts()[0].name, 'John Smith')
self.assertEqual(m.contacts()[0].organization, 'ACME')
self.assertEqual(m.contacts()[0].position, 'staff')
self.assertEqual(m.contacts()[0].voice, '1500 515 555')
self.assertEqual(m.contacts()[0].fax, 'xx.xxx.xxx.xxxx')
self.assertEqual(m.contacts()[0].email, '*****@*****.**')
self.assertEqual(m.contacts()[0].role, 'pointOfContact')
self.assertEqual(m.contacts()[0].addresses[0].type, 'postal')
self.assertEqual(m.contacts()[0].addresses[0].address,
'123 Main Street')
self.assertEqual(m.contacts()[0].addresses[0].city, 'anycity')
self.assertEqual(m.contacts()[0].addresses[0].administrativeArea,
'anyprovince')
self.assertEqual(m.contacts()[0].addresses[0].postalCode, '90210')
self.assertEqual(m.contacts()[0].addresses[0].country, 'Canada')
self.assertEqual(m.links()[0].name, 'geonode:roads')
self.assertEqual(m.links()[0].type, 'OGC:WMS')
self.assertEqual(m.links()[0].description, 'my GeoNode road layer')
self.assertEqual(m.links()[0].url, 'http://example.org/wms')
self.assertEqual(m.links()[1].name, 'geonode:roads')
self.assertEqual(m.links()[1].type, 'OGC:WFS')
self.assertEqual(m.links()[1].description, 'my GeoNode road layer')
self.assertEqual(m.links()[1].url, 'http://example.org/wfs')
self.assertEqual(m.links()[2].name, 'roads')
self.assertEqual(m.links()[2].type, 'WWW:LINK')
self.assertEqual(m.links()[2].description, 'full dataset download')
self.assertEqual(m.links()[2].url, 'http://example.org/roads.tgz')
self.assertEqual(m.links()[2].format, 'ESRI Shapefile')
self.assertEqual(m.links()[2].mimeType, 'application/gzip')
self.assertEqual(m.links()[2].size, '283676')
self.assertEqual(m.author(), 'my author')
self.assertEqual(m.creationDateTime(),
QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47)))
def testDualFieldMode(self):
layer = QgsVectorLayer(
"Point?field=fldtxt:string&field=fldint:integer&field=start_field:datetime&field=end_field:datetime",
"test", "memory")
self.assertTrue(layer.isValid())
self.assertEqual(layer.fields()[2].type(), QVariant.DateTime)
self.assertEqual(layer.fields()[3].type(), QVariant.DateTime)
range = QgsDateTimeRange(
QDateTime(QDate(2019, 3, 4), QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)))
props = QgsVectorLayerTemporalProperties(enabled=False)
props.setMode(QgsVectorLayerTemporalProperties.
ModeFeatureDateTimeStartAndEndFromFields)
props.setStartField('start_field')
props.setEndField('end_field')
self.assertFalse(props.createFilterString(layer, range))
props.setIsActive(True)
self.assertEqual(
props.createFilterString(layer, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND ("end_field" >= make_datetime(2019,3,4,11,12,13) OR "end_field" IS NULL)'
)
range = QgsDateTimeRange(QDateTime(QDate(2019, 3, 4),
QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)),
includeBeginning=False)
self.assertEqual(
props.createFilterString(layer, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND ("end_field" > make_datetime(2019,3,4,11,12,13) OR "end_field" IS NULL)'
)
range = QgsDateTimeRange(QDateTime(QDate(2019, 3, 4),
QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)),
includeEnd=False)
self.assertEqual(
props.createFilterString(layer, range),
'("start_field" < make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND ("end_field" >= make_datetime(2019,3,4,11,12,13) OR "end_field" IS NULL)'
)
props.setEndField('')
self.assertEqual(
props.createFilterString(layer, range),
'"start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL'
)
range = QgsDateTimeRange(QDateTime(QDate(2019, 3, 4),
QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)),
includeBeginning=False)
self.assertEqual(
props.createFilterString(layer, range),
'"start_field" < make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL'
)
range = QgsDateTimeRange(QDateTime(QDate(2019, 3, 4),
QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)),
includeEnd=False)
self.assertEqual(
props.createFilterString(layer, range),
'"start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL'
)
props.setStartField('')
props.setEndField('end_field')
self.assertEqual(
props.createFilterString(layer, range),
'"end_field" >= make_datetime(2019,3,4,11,12,13) OR "end_field" IS NULL'
)
range = QgsDateTimeRange(QDateTime(QDate(2019, 3, 4),
QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)),
includeBeginning=False)
self.assertEqual(
props.createFilterString(layer, range),
'"end_field" > make_datetime(2019,3,4,11,12,13) OR "end_field" IS NULL'
)
range = QgsDateTimeRange(QDateTime(QDate(2019, 3, 4),
QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)),
includeEnd=False)
self.assertEqual(
props.createFilterString(layer, range),
'"end_field" >= make_datetime(2019,3,4,11,12,13) OR "end_field" IS NULL'
)
def updatePlotXLine(self):
if self.predictionCanvas is not None:
x = QTime(0, 0).secsTo(self.timeEdit.time()) / 3600.0
self.plotXLine.set_xdata([x, x])
self.plotAxes.figure.canvas.draw()
def createTestMetadata(self):
"""
Returns a standard metadata which can be tested with checkExpectedMetadata
"""
m = QgsLayerMetadata()
m.setIdentifier('1234')
m.setParentIdentifier('xyz')
m.setLanguage('en-CA')
m.setType('dataset')
m.setTitle('roads')
m.setAbstract('my roads')
m.setFees('None')
m.setConstraints([QgsLayerMetadata.Constraint('None', 'access')])
m.setRights(['Copyright foo 2017'])
m.setLicenses(['WTFPL'])
m.setHistory(['history a', 'history b'])
m.setKeywords({
'GEMET': ['kw1', 'kw2'],
'gmd:topicCategory': ['natural'],
})
m.setEncoding('utf-8')
m.setCrs(QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4326'))
e = QgsLayerMetadata.Extent()
se = QgsLayerMetadata.SpatialExtent()
se.extentCrs = QgsCoordinateReferenceSystem.fromOgcWmsCrs('EPSG:4326')
se.bounds = QgsBox3d(-180, -90, 0, 180, 90, 0)
e.setSpatialExtents([se])
dates = [
QgsDateTimeRange(QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47)),
QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47))),
QgsDateTimeRange(QDateTime(QDate(2010, 12, 17), QTime(9, 30, 47)),
QDateTime(QDate(2020, 12, 17), QTime(9, 30, 47)))
]
e.setTemporalExtents(dates)
m.setExtent(e)
c = QgsLayerMetadata.Contact()
c.name = 'John Smith'
c.organization = 'ACME'
c.position = 'staff'
c.voice = '1500 515 555'
c.fax = 'xx.xxx.xxx.xxxx'
c.email = '*****@*****.**'
c.role = 'pointOfContact'
address = QgsLayerMetadata.Address()
address.type = 'postal'
address.address = '123 Main Street'
address.city = 'anycity'
address.administrativeArea = 'anyprovince'
address.postalCode = '90210'
address.country = 'Canada'
c.addresses = [address]
m.setContacts([c])
l = QgsLayerMetadata.Link()
l.name = 'geonode:roads'
l.type = 'OGC:WMS'
l.description = 'my GeoNode road layer'
l.url = 'http://example.org/wms'
l2 = QgsLayerMetadata.Link()
l2.name = 'geonode:roads'
l2.type = 'OGC:WFS'
l2.description = 'my GeoNode road layer'
l2.url = 'http://example.org/wfs'
l3 = QgsLayerMetadata.Link()
l3.name = 'roads'
l3.type = 'WWW:LINK'
l3.description = 'full dataset download'
l3.url = 'http://example.org/roads.tgz'
l3.format = 'ESRI Shapefile'
l3.mimeType = 'application/gzip'
l3.size = '283676'
m.setLinks([l, l2, l3])
return m
def testExportToImage(self):
md = QgsProject.instance().metadata()
md.setTitle('proj title')
md.setAuthor('proj author')
md.setCreationDateTime(QDateTime(QDate(2011, 5, 3), QTime(9, 4, 5), QTimeZone(36000)))
md.setIdentifier('proj identifier')
md.setAbstract('proj abstract')
md.setKeywords({'kw': ['kw1', 'kw2'], 'KWx': ['kw3', 'kw4']})
QgsProject.instance().setMetadata(md)
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add a second page
page2 = QgsLayoutItemPage(l)
page2.setPageSize('A5')
l.pageCollection().addPage(page2)
# add some items
item1 = QgsLayoutItemShape(l)
item1.attemptSetSceneRect(QRectF(10, 20, 100, 150))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.green)
fill.setStrokeStyle(Qt.NoPen)
item1.setSymbol(fill_symbol)
l.addItem(item1)
item2 = QgsLayoutItemShape(l)
item2.attemptSetSceneRect(QRectF(10, 20, 100, 150))
item2.attemptMove(QgsLayoutPoint(10, 20), page=1)
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.cyan)
fill.setStrokeStyle(Qt.NoPen)
item2.setSymbol(fill_symbol)
l.addItem(item2)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.ImageExportSettings()
settings.dpi = 80
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagedpi.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(self.checkImage('exporttoimagedpi_page1', 'exporttoimagedpi_page1', rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagedpi_2.png')
self.assertTrue(self.checkImage('exporttoimagedpi_page2', 'exporttoimagedpi_page2', page2_path))
for f in (rendered_file_path, page2_path):
d = gdal.Open(f)
metadata = d.GetMetadata()
self.assertEqual(metadata['Author'], 'proj author')
self.assertEqual(metadata['Created'], '2011-05-03T09:04:05+10:00')
self.assertEqual(metadata['Keywords'], 'KWx: kw3,kw4;kw: kw1,kw2')
self.assertEqual(metadata['Subject'], 'proj abstract')
self.assertEqual(metadata['Title'], 'proj title')
# crop to contents
settings.cropToContents = True
settings.cropMargins = QgsMargins(10, 20, 30, 40)
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagecropped.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(self.checkImage('exporttoimagecropped_page1', 'exporttoimagecropped_page1', rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagecropped_2.png')
self.assertTrue(self.checkImage('exporttoimagecropped_page2', 'exporttoimagecropped_page2', page2_path))
# specific pages
settings.cropToContents = False
settings.pages = [1]
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagepages.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagepages_2.png')
self.assertTrue(self.checkImage('exporttoimagedpi_page2', 'exporttoimagedpi_page2', page2_path))
# image size
settings.imageSize = QSize(600, 851)
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagesize.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
self.assertFalse(os.path.exists(rendered_file_path))
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagesize_2.png')
self.assertTrue(self.checkImage('exporttoimagesize_page2', 'exporttoimagesize_page2', page2_path))
# image size with incorrect aspect ratio
# this can happen as a result of data defined page sizes
settings.imageSize = QSize(851, 600)
rendered_file_path = os.path.join(self.basetestpath, 'test_exporttoimagesizebadaspect.png')
self.assertEqual(exporter.exportToImage(rendered_file_path, settings), QgsLayoutExporter.Success)
page2_path = os.path.join(self.basetestpath, 'test_exporttoimagesizebadaspect_2.png')
im = QImage(page2_path)
self.assertTrue(self.checkImage('exporttoimagesize_badaspect', 'exporttoimagedpi_page2', page2_path), '{}x{}'.format(im.width(), im.height()))
def predictionsResolved(self):
# Check to see if the resolved signal is for data we currently care about.
# if not, then just bail
if self.stationData is None or self.stationData.state != PredictionPromise.ResolvedState:
return
""" when we have predictions for the current station, show them in the
plot and table widget.
"""
if self.predictionCanvas is not None:
self.predictionCanvas.mpl_disconnect(self.plotCallbackId)
self.plotLayout.removeWidget(self.predictionCanvas)
self.predictionCanvas.hide()
self.predictionCanvas = FigureCanvas(Figure(figsize=(5, 3)))
self.plotLayout.addWidget(self.predictionCanvas)
self.plotAxes = self.predictionCanvas.figure.subplots()
# zero time in this plot = 00:00 local time on the date of interest
t0 = QDateTime(self.dateEdit.date(), QTime(0, 0),
stationTimeZone(self.stationFeature)).toUTC()
t = []
val = []
for f in self.stationData.predictions:
if f['type'] == 'current':
utcTime = f['time']
utcTime.setTimeSpec(Qt.TimeSpec.UTC)
t.append(t0.secsTo(utcTime) / 3600)
val.append(f['value'])
self.plotAxes.set_xlim(left=0, right=24)
self.plotAxes.set_xticks([0, 3, 6, 9, 12, 15, 18, 21, 24])
self.plotAxes.grid(linewidth=0.5)
y0line = self.plotAxes.axhline(y=0)
y0line.set_linestyle(':')
y0line.set_linewidth(1)
self.plotXLine = self.plotAxes.axvline(x=0)
self.plotXLine.set_linestyle(':')
self.plotXLine.set_linewidth(1)
self.updatePlotXLine()
self.plotAxes.plot(t, val)
self.plotCallbackId = self.predictionCanvas.mpl_connect(
'button_release_event', self.handlePlotClick)
QgsProject.instance()._ax = self.plotAxes
self.tableWidget.setRowCount(len(self.stationData.predictions))
i = 0
for p in self.stationData.predictions:
dt = p['time']
dt.setTimeSpec(Qt.TimeSpec.UTC)
if self.includeCurrentsInTable and p[
'type'] == 'current' and p['dir'] != NULL:
self.tableWidget.setItem(
i, 0,
QTableWidgetItem(
dt.toTimeZone(self.stationZone).toString('h:mm AP')))
self.tableWidget.setItem(
i, 1, QTableWidgetItem(str(round(p['dir'])) + 'º'))
self.tableWidget.setItem(
i, 2, QTableWidgetItem("{:.2f}".format(p['magnitude'])))
i += 1
elif p['type'] != 'current':
self.tableWidget.setItem(
i, 0,
QTableWidgetItem(
dt.toTimeZone(self.stationZone).toString('h:mm AP')))
self.tableWidget.setItem(i, 1, QTableWidgetItem(p['type']))
self.tableWidget.setItem(
i, 2, QTableWidgetItem("{:.2f}".format(p['value'])))
self.tableWidget.setRowHeight(i, 20)
i += 1
self.tableWidget.setRowCount(i)
def testExportToPdf(self):
md = QgsProject.instance().metadata()
md.setTitle('proj title')
md.setAuthor('proj author')
md.setCreationDateTime(QDateTime(QDate(2011, 5, 3), QTime(9, 4, 5), QTimeZone(36000)))
md.setIdentifier('proj identifier')
md.setAbstract('proj abstract')
md.setKeywords({'kw': ['kw1', 'kw2'], 'KWx': ['kw3', 'kw4']})
QgsProject.instance().setMetadata(md)
l = QgsLayout(QgsProject.instance())
l.initializeDefaults()
# add a second page
page2 = QgsLayoutItemPage(l)
page2.setPageSize('A5')
l.pageCollection().addPage(page2)
# add some items
item1 = QgsLayoutItemShape(l)
item1.attemptSetSceneRect(QRectF(10, 20, 100, 150))
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.green)
fill.setStrokeStyle(Qt.NoPen)
item1.setSymbol(fill_symbol)
l.addItem(item1)
item2 = QgsLayoutItemShape(l)
item2.attemptSetSceneRect(QRectF(10, 20, 100, 150))
item2.attemptMove(QgsLayoutPoint(10, 20), page=1)
fill = QgsSimpleFillSymbolLayer()
fill_symbol = QgsFillSymbol()
fill_symbol.changeSymbolLayer(0, fill)
fill.setColor(Qt.cyan)
fill.setStrokeStyle(Qt.NoPen)
item2.setSymbol(fill_symbol)
l.addItem(item2)
exporter = QgsLayoutExporter(l)
# setup settings
settings = QgsLayoutExporter.PdfExportSettings()
settings.dpi = 80
settings.rasterizeWholeImage = False
settings.forceVectorOutput = False
settings.exportMetadata = True
pdf_file_path = os.path.join(self.basetestpath, 'test_exporttopdfdpi.pdf')
self.assertEqual(exporter.exportToPdf(pdf_file_path, settings), QgsLayoutExporter.Success)
self.assertTrue(os.path.exists(pdf_file_path))
rendered_page_1 = os.path.join(self.basetestpath, 'test_exporttopdfdpi.png')
dpi = 80
pdfToPng(pdf_file_path, rendered_page_1, dpi=dpi, page=1)
rendered_page_2 = os.path.join(self.basetestpath, 'test_exporttopdfdpi2.png')
pdfToPng(pdf_file_path, rendered_page_2, dpi=dpi, page=2)
self.assertTrue(self.checkImage('exporttopdfdpi_page1', 'exporttopdfdpi_page1', rendered_page_1, size_tolerance=1))
self.assertTrue(self.checkImage('exporttopdfdpi_page2', 'exporttopdfdpi_page2', rendered_page_2, size_tolerance=1))
d = gdal.Open(pdf_file_path)
metadata = d.GetMetadata()
self.assertEqual(metadata['AUTHOR'], 'proj author')
self.assertEqual(metadata['CREATION_DATE'], "D:20110503090405+10'0'")
self.assertEqual(metadata['KEYWORDS'], 'KWx: kw3,kw4;kw: kw1,kw2')
self.assertEqual(metadata['SUBJECT'], 'proj abstract')
self.assertEqual(metadata['TITLE'], 'proj title')
def handlePlotClick(self, event):
minutes = PredictionManager.STEP_MINUTES * (
event.xdata * 60 // PredictionManager.STEP_MINUTES)
self.timeEdit.setTime(QTime(minutes // 60, minutes % 60))
