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 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 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 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 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 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)],
[
QgsAggregateCalculator.ArrayAggregate, 'flddatetime',
[None if v.isNull() else v for v in datetime_values]
],
[
QgsAggregateCalculator.ArrayAggregate, 'flddate',
[None if v.isNull() else v for v in date_values]
],
]
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 testStartAndDurationMode(self):
layer = QgsVectorLayer(
"Point?field=fldtxt:string&field=fldint:integer&field=start_field:datetime&field=duration:double",
"test", "memory")
self.assertTrue(layer.isValid())
self.assertEqual(layer.fields()[2].type(), QVariant.DateTime)
self.assertEqual(layer.fields()[3].type(), QVariant.Double)
context = QgsVectorLayerTemporalContext()
context.setLayer(layer)
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.
ModeFeatureDateTimeStartAndDurationFromFields)
props.setStartField('start_field')
props.setDurationField('duration')
props.setDurationUnits(QgsUnitTypes.TemporalMilliseconds)
self.assertFalse(props.createFilterString(context, range))
props.setIsActive(True)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND (("start_field" + make_interval(0,0,0,0,0,0,"duration"/1000) >= make_datetime(2019,3,4,11,12,13)) OR "duration" IS NULL)'
)
props.setDurationUnits(QgsUnitTypes.TemporalSeconds)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND (("start_field" + make_interval(0,0,0,0,0,0,"duration") >= make_datetime(2019,3,4,11,12,13)) OR "duration" IS NULL)'
)
props.setDurationUnits(QgsUnitTypes.TemporalMinutes)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND (("start_field" + make_interval(0,0,0,0,0,"duration",0) >= make_datetime(2019,3,4,11,12,13)) OR "duration" IS NULL)'
)
props.setDurationUnits(QgsUnitTypes.TemporalHours)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND (("start_field" + make_interval(0,0,0,0,"duration",0,0) >= make_datetime(2019,3,4,11,12,13)) OR "duration" IS NULL)'
)
props.setDurationUnits(QgsUnitTypes.TemporalDays)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND (("start_field" + make_interval(0,0,0,"duration",0,0,0) >= make_datetime(2019,3,4,11,12,13)) OR "duration" IS NULL)'
)
props.setDurationUnits(QgsUnitTypes.TemporalWeeks)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND (("start_field" + make_interval(0,0,"duration",0,0,0,0) >= make_datetime(2019,3,4,11,12,13)) OR "duration" IS NULL)'
)
props.setDurationUnits(QgsUnitTypes.TemporalMonths)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND (("start_field" + make_interval(0,"duration",0,0,0,0,0) >= make_datetime(2019,3,4,11,12,13)) OR "duration" IS NULL)'
)
props.setDurationUnits(QgsUnitTypes.TemporalYears)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND (("start_field" + make_interval("duration",0,0,0,0,0,0) >= make_datetime(2019,3,4,11,12,13)) OR "duration" IS NULL)'
)
props.setDurationUnits(QgsUnitTypes.TemporalDecades)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND (("start_field" + make_interval(10 * "duration",0,0,0,0,0,0) >= make_datetime(2019,3,4,11,12,13)) OR "duration" IS NULL)'
)
props.setDurationUnits(QgsUnitTypes.TemporalCenturies)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" <= make_datetime(2020,5,6,8,9,10) OR "start_field" IS NULL) AND (("start_field" + make_interval(100 * "duration",0,0,0,0,0,0) >= make_datetime(2019,3,4,11,12,13)) OR "duration" IS NULL)'
)
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']})
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])
e.setTemporalExtents([
QgsDateTimeRange(QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47)),
QDateTime(QDate(2001, 12, 17), QTime(9, 30, 47)))
])
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 updateDateTime(self, id=Update.ALL):
# print('updateDateTime')
if self.hourModeCheckBox.isChecked():
self.timeEdit.setDisplayFormat("HH:mm:ss")
else:
self.timeEdit.setDisplayFormat("hh:mm:ss AP")
dt = self.getLocalDateTime()
# offset = int(dt.tzinfo.utcoffset(dt).total_seconds()/3600.0)
offset = dt.strftime('%z')
if id != Update.DATE:
self.dateEdit.blockSignals(True)
self.dateEdit.setDate(QDate(dt.year, dt.month, dt.day))
self.dateEdit.blockSignals(False)
if id != Update.TIME:
self.timeEdit.blockSignals(True)
self.timeEdit.setTime(
QTime(dt.hour, dt.minute, dt.second,
int(dt.microsecond / 1000)))
self.timeEdit.blockSignals(False)
if id != Update.EPOCH:
try:
sec = int(
(self.dt_utc -
datetime.fromtimestamp(0, pytz.utc)).total_seconds())
except Exception:
sec = 'Undefined'
self.epochLineEdit.setText('{}'.format(sec))
if id != Update.EPOCHMS:
try:
msec = int(
(self.dt_utc -
datetime.fromtimestamp(0, pytz.utc)).total_seconds() *
1000.0)
except Exception:
msec = 'Undefined'
self.epochmsLineEdit.setText('{}'.format(msec))
if id != Update.TIME_ZONE:
# This should always be true because we have forced the timezone to adhear to the list
name = dt.tzinfo.zone
id = self.timezoneComboBox.findText(name, Qt.MatchExactly)
self.timezoneComboBox.blockSignals(True)
self.timezoneComboBox.setCurrentIndex(id)
self.timezoneComboBox.blockSignals(False)
if id != Update.JULIAN:
(val1, val2) = gcal2jd(dt.year, dt.month, dt.day)
self.julienLineEdit.setText('{}'.format(val1 + val2))
if id != Update.UTC:
if dt.microsecond == 0:
self.iso8601LineEdit.setText(
self.dt_utc.strftime('%Y-%m-%dT%H:%M:%SZ'))
else:
self.iso8601LineEdit.setText(
self.dt_utc.strftime('%Y-%m-%dT%H:%M:%S.%fZ'))
tinfo = dt.timetuple()
self.dayOfWeekLineEdit.setText(DOW[tinfo.tm_wday])
self.doyLineEdit.setText('{}'.format(tinfo.tm_yday))
# self.timezoneOffsetLineEdit.setText('{:+d}'.format(offset))
self.timezoneOffsetLineEdit.setText(offset)
self.updateTimeDelta()
self.updateSunMoon()
self.updateReverseGeo()
def testSingleFieldMode(self):
layer = QgsVectorLayer(
"Point?field=fldtxt:string&field=fldint:integer&field=start_field:datetime",
"test", "memory")
self.assertTrue(layer.isValid())
self.assertEqual(layer.fields()[2].type(), QVariant.DateTime)
context = QgsVectorLayerTemporalContext()
context.setLayer(layer)
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.
ModeFeatureDateTimeInstantFromField)
props.setStartField('start_field')
self.assertFalse(props.createFilterString(context, range))
props.setIsActive(True)
self.assertEqual(
props.createFilterString(context, range),
'("start_field" >= make_datetime(2019,3,4,11,12,13) AND "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(context, range),
'("start_field" > make_datetime(2019,3,4,11,12,13) AND "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(context, range),
'("start_field" >= make_datetime(2019,3,4,11,12,13) AND "start_field" < make_datetime(2020,5,6,8,9,10)) OR "start_field" IS NULL'
)
# with fixed duration
props.setFixedDuration(3)
props.setDurationUnits(QgsUnitTypes.TemporalDays)
range = QgsDateTimeRange(
QDateTime(QDate(2019, 3, 4), QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)))
self.assertEqual(
props.createFilterString(context, range),
'("start_field" >= make_datetime(2019,3,1,11,12,13) AND "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(context, range),
'("start_field" > make_datetime(2019,3,1,11,12,13) AND "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(context, range),
'("start_field" >= make_datetime(2019,3,1,11,12,13) AND "start_field" < make_datetime(2020,5,6,8,9,10)) OR "start_field" IS NULL'
)
props.setDurationUnits(QgsUnitTypes.TemporalMinutes)
range = QgsDateTimeRange(
QDateTime(QDate(2019, 3, 4), QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)))
self.assertEqual(
props.createFilterString(context, range),
'("start_field" >= make_datetime(2019,3,4,11,9,13) AND "start_field" <= make_datetime(2020,5,6,8,9,10)) OR "start_field" IS NULL'
)
# accumulate mode
props.setAccumulateFeatures(True)
range = QgsDateTimeRange(
QDateTime(QDate(2019, 3, 4), QTime(11, 12, 13)),
QDateTime(QDate(2020, 5, 6), QTime(8, 9, 10)))
self.assertEqual(
props.createFilterString(context, 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(context, 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(context, range),
'("start_field" < make_datetime(2020,5,6,8,9,10)) OR "start_field" IS NULL'
)
def testTemporal1(self):
"""
Test timeinfo parsing
"""
endpoint = self.basetestpath + '/temporal1_fake_qgis_http_endpoint'
with open(sanitize(endpoint, '?f=json'), 'wb') as f:
f.write("""
{"currentVersion":10.22,"id":1,"name":"QGIS Test","type":"Feature Layer","description":
"QGIS Provider Test Layer.\n","geometryType":"esriGeometryPoint","copyrightText":"","parentLayer":{"id":0,"name":"QGIS Tests"},"subLayers":[],
"minScale":72225,"maxScale":0,
"defaultVisibility":true,
"extent":{"xmin":-71.123,"ymin":66.33,"xmax":-65.32,"ymax":78.3,
"spatialReference":{"wkid":4326,"latestWkid":4326}},
"hasAttachments":false,"htmlPopupType":"esriServerHTMLPopupTypeAsHTMLText",
"displayField":"LABEL","typeIdField":null,
"fields":[{"name":"OBJECTID","type":"esriFieldTypeOID","alias":"OBJECTID","domain":null}
],
"timeInfo": {
"startTimeField": "date_start",
"endTimeField": null,
"trackIdField": null,
"timeExtent": [
1142000000000,
1487000000000
]
},
"relationships":[],"canModifyLayer":false,"canScaleSymbols":false,"hasLabels":false,
"capabilities":"Map,Query,Data","maxRecordCount":1000,"supportsStatistics":true,
"supportsAdvancedQueries":true,"supportedQueryFormats":"JSON, AMF",
"ownershipBasedAccessControlForFeatures":{"allowOthersToQuery":true},"useStandardizedQueries":true}"""
.encode('UTF-8'))
with open(
sanitize(endpoint,
'/query?f=json_where=1=1&returnIdsOnly=true'),
'wb') as f:
f.write("""
{
"objectIdFieldName": "OBJECTID",
"objectIds": [
1,
2,
3
]
}
""".encode('UTF-8'))
# Create test layer
vl = QgsVectorLayer("url='http://" + endpoint + "' crs='epsg:4326'",
'test', 'arcgisfeatureserver')
self.assertTrue(vl.isValid())
self.assertTrue(
vl.dataProvider().temporalCapabilities().hasTemporalCapabilities())
self.assertEqual(vl.dataProvider().temporalCapabilities().startField(),
'date_start')
self.assertFalse(vl.dataProvider().temporalCapabilities().endField())
self.assertEqual(
vl.dataProvider().temporalCapabilities().mode(),
QgsVectorDataProviderTemporalCapabilities.
ProviderStoresFeatureDateTimeInstantInField)
self.assertEqual(
vl.dataProvider().temporalCapabilities().availableTemporalRange().
begin(), QDateTime(QDate(2006, 3, 10), QTime(14, 13, 20), Qt.UTC))
self.assertEqual(
vl.dataProvider().temporalCapabilities().availableTemporalRange().
end(), QDateTime(QDate(2017, 2, 13), QTime(15, 33, 20), Qt.UTC))
def test_temporal_animation(self):
"""
Test temporal animation logic
"""
canvas = QgsMapCanvas()
self.assertEqual(canvas.mapSettings().frameRate(), -1)
self.assertEqual(canvas.mapSettings().currentFrame(), -1)
controller = QgsTemporalController()
canvas.setTemporalController(controller)
controller.updateTemporalRange.emit(
QgsDateTimeRange(QDateTime(QDate(2020, 1, 2), QTime(1, 2, 3)),
QDateTime(QDate(2020, 1, 4), QTime(1, 2, 3))))
# should be no change
self.assertEqual(canvas.mapSettings().frameRate(), -1)
self.assertEqual(canvas.mapSettings().currentFrame(), -1)
temporal_no = QgsTemporalNavigationObject()
temporal_no.setTemporalExtents(
QgsDateTimeRange(QDateTime(QDate(2020, 1, 2), QTime(1, 2, 3)),
QDateTime(QDate(2020, 1, 4), QTime(1, 2, 3))))
temporal_no.setFrameDuration(QgsInterval(0, 0, 0, 0, 1, 0, 0))
canvas.setTemporalController(temporal_no)
controller.updateTemporalRange.emit(
QgsDateTimeRange(QDateTime(QDate(2020, 1, 2), QTime(1, 2, 3)),
QDateTime(QDate(2020, 1, 4), QTime(1, 2, 3))))
# should be no change
self.assertEqual(canvas.mapSettings().frameRate(), -1)
self.assertEqual(canvas.mapSettings().currentFrame(), -1)
temporal_no.setFramesPerSecond(30)
temporal_no.pause()
temporal_no.setCurrentFrameNumber(6)
canvas.refresh()
# should be no change - temporal controller is not in animation mode
self.assertEqual(canvas.mapSettings().frameRate(), -1)
self.assertEqual(canvas.mapSettings().currentFrame(), -1)
temporal_no.setNavigationMode(QgsTemporalNavigationObject.Animated)
self.assertEqual(canvas.mapSettings().frameRate(), 30)
self.assertEqual(canvas.mapSettings().currentFrame(), 6)
temporal_no.setCurrentFrameNumber(7)
self.assertEqual(canvas.mapSettings().frameRate(), 30)
self.assertEqual(canvas.mapSettings().currentFrame(), 6)
# switch off animation mode
temporal_no.setNavigationMode(QgsTemporalNavigationObject.FixedRange)
self.assertEqual(canvas.mapSettings().frameRate(), -1)
self.assertEqual(canvas.mapSettings().currentFrame(), -1)
temporal_no.setNavigationMode(QgsTemporalNavigationObject.Animated)
self.assertEqual(canvas.mapSettings().frameRate(), 30)
self.assertEqual(canvas.mapSettings().currentFrame(), 7)
temporal_no.setNavigationMode(
QgsTemporalNavigationObject.NavigationOff)
self.assertEqual(canvas.mapSettings().frameRate(), -1)
self.assertEqual(canvas.mapSettings().currentFrame(), -1)
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 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 testExpressionMode(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)
context = QgsVectorLayerTemporalContext()
context.setLayer(layer)
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.
ModeFeatureDateTimeStartAndEndFromExpressions)
props.setStartExpression(
'to_datetime("my string field", \'yyyy MM dd hh::mm:ss\')"')
props.setEndExpression(
'to_datetime("my end field", \'yyyy MM dd hh::mm:ss\')"')
self.assertFalse(props.createFilterString(context, range))
props.setIsActive(True)
self.assertEqual(
props.createFilterString(context, range),
'((to_datetime("my string field", \'yyyy MM dd hh::mm:ss\')") <= make_datetime(2020,5,6,8,9,10)) AND ((to_datetime("my end field", \'yyyy MM dd hh::mm:ss\')") >= make_datetime(2019,3,4,11,12,13))'
)
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(context, range),
'((to_datetime("my string field", \'yyyy MM dd hh::mm:ss\')") <= make_datetime(2020,5,6,8,9,10)) AND ((to_datetime("my end field", \'yyyy MM dd hh::mm:ss\')") > make_datetime(2019,3,4,11,12,13))'
)
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(context, range),
'((to_datetime("my string field", \'yyyy MM dd hh::mm:ss\')") < make_datetime(2020,5,6,8,9,10)) AND ((to_datetime("my end field", \'yyyy MM dd hh::mm:ss\')") >= make_datetime(2019,3,4,11,12,13))'
)
props.setEndExpression('')
self.assertEqual(
props.createFilterString(context, range),
'(to_datetime("my string field", \'yyyy MM dd hh::mm:ss\')") <= make_datetime(2020,5,6,8,9,10)'
)
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(context, range),
'(to_datetime("my string field", \'yyyy MM dd hh::mm:ss\')") < make_datetime(2020,5,6,8,9,10)'
)
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(context, range),
'(to_datetime("my string field", \'yyyy MM dd hh::mm:ss\')") <= make_datetime(2020,5,6,8,9,10)'
)
props.setStartExpression('')
props.setEndExpression(
'to_datetime("my end field", \'yyyy MM dd hh::mm:ss\')"')
self.assertEqual(
props.createFilterString(context, range),
'(to_datetime("my end field", \'yyyy MM dd hh::mm:ss\')") >= make_datetime(2019,3,4,11,12,13)'
)
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(context, range),
'(to_datetime("my end field", \'yyyy MM dd hh::mm:ss\')") > make_datetime(2019,3,4,11,12,13)'
)
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(context, range),
'(to_datetime("my end field", \'yyyy MM dd hh::mm:ss\')") >= make_datetime(2019,3,4,11,12,13)'
)
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 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 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 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 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 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 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.asWkt(),
'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 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 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 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 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 handlePlotClick(self, event):
minutes = PredictionManager.STEP_MINUTES * (
event.xdata * 60 // PredictionManager.STEP_MINUTES)
self.timeEdit.setTime(QTime(minutes // 60, minutes % 60))
