def testDateTimeTypes(self):
vl = QgsVectorLayer(
'%s table="qgis_test"."date_times" sql=' % (self.dbconn),
"testdatetimes", "postgres")
assert (vl.isValid())
fields = vl.dataProvider().fields()
self.assertEqual(
fields.at(fields.indexFromName('date_field')).type(),
QVariant.Date)
self.assertEqual(
fields.at(fields.indexFromName('time_field')).type(),
QVariant.Time)
self.assertEqual(
fields.at(fields.indexFromName('datetime_field')).type(),
QVariant.DateTime)
f = vl.getFeatures(QgsFeatureRequest()).next()
date_idx = vl.fieldNameIndex('date_field')
assert isinstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2004, 3, 4))
time_idx = vl.fieldNameIndex('time_field')
assert isinstance(f.attributes()[time_idx], QTime)
self.assertEqual(f.attributes()[time_idx], QTime(13, 41, 52))
datetime_idx = vl.fieldNameIndex('datetime_field')
assert isinstance(f.attributes()[datetime_idx], QDateTime)
self.assertEqual(f.attributes()[datetime_idx],
QDateTime(QDate(2004, 3, 4), QTime(13, 41, 52)))
def Init(self, song, data, bitrate):
""" Initialize with song.
:param song: input song
:type song: list
:param data: input data from wav file
:type data: numpy.array
:param bitrate: bitrate of input file
:type bitrate: int
"""
self.song = copy.deepcopy(song)
self.index = self.song[0]
self.name = self.song[1]
self.ui.saveButton.setText(self.name)
self.data = data
self.resetData = copy.deepcopy(song)
self.bitrate = bitrate
h, m, s = EditForm.ParseTime(self.song[2])
self.ui.startTime.setTime(QTime(h, m, s))
h, m, s = EditForm.ParseTime(self.song[3])
self.ui.endTime.setTime(QTime(h, m, s))
end_time = datetime.timedelta(seconds=int(self.data.shape[0] /
self.bitrate))
h, m, s = EditForm.ParseTime(str(end_time))
self.ui.endTime.setMaximumTime(QTime(h, m, s))
def __init__(self, ganttWidget):
super(XGanttWidgetItem, self).__init__()
# set default properties
self.setFixedHeight(ganttWidget.cellHeight())
for i in range(1, 20):
self.setTextAlignment(i, Qt.AlignCenter)
# define custom properties
self._blockedAdjustments = {}
self._viewItem = self.createViewItem()
self._dateStart = QDate.currentDate()
self._dateEnd = QDate.currentDate()
self._allDay = True
self._timeStart = QTime(0, 0, 0)
self._timeEnd = QTime(23, 59, 59)
self._name = "NONE"
self._properties = {}
self._itemStyle = XGanttWidgetItem.ItemStyle.Normal
self._useGroupStyleWithChildren = True
self._dependencies = {}
self._reverseDependencies = {}
self._dbEntry = None
self._workdays = 0
self._ganttWidget = ganttWidget
#self._calculateWeekdays = 0
#self._dbDepartmentAssignment = ''
self.setPrivelages()
def toQDateTime(dt):
if isinstance(dt, datetime.date):
return QDateTime(Serializeable.toQDate(dt), QTime())
elif isinstance(dt, datetime.datetime):
return QDateTime(Serializeable.toQDate(dt),
QTime(dt.hour, dt.minute, dt.second))
return QDateTime()
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')
assert ml is not None, 'Provider not initialised'
assert ml.isValid(), 'Source layer not valid'
provider = ml.dataProvider()
assert provider is not None
ft = QgsFeature()
ft.setGeometry(QgsGeometry.fromPoint(QgsPoint(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])
assert res
assert len(features) > 0
dest_file_name = os.path.join(str(QDir.tempPath()), 'datetime.shp')
print(dest_file_name)
crs = QgsCoordinateReferenceSystem()
crs.createFromId(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
write_result = QgsVectorFileWriter.writeAsVectorFormat(
ml, dest_file_name, 'utf-8', crs, 'ESRI Shapefile')
self.assertEqual(write_result, QgsVectorFileWriter.NoError)
# Open result and check
created_layer = QgsVectorLayer(u'{}|layerid=0'.format(dest_file_name),
u'test', u'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 date
self.assertEqual(
fields.at(fields.indexFromName('dt_f')).type(), QVariant.Date)
f = created_layer.getFeatures(QgsFeatureRequest()).next()
date_idx = created_layer.fieldNameIndex('date_f')
assert isinstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2014, 3, 5))
time_idx = created_layer.fieldNameIndex('time_f')
#shapefiles do not support time types
assert isinstance(f.attributes()[time_idx], basestring)
self.assertEqual(f.attributes()[time_idx], '13:45:22')
#shapefiles do not support datetime types
datetime_idx = created_layer.fieldNameIndex('dt_f')
assert isinstance(f.attributes()[datetime_idx], QDate)
self.assertEqual(f.attributes()[datetime_idx], QDate(2014, 3, 5))
def HandleResetButton(self):
""" Handle reset button. Resets to default configuration.
"""
self.ui.saveButton.setText(self.resetData[1])
h, m, s = EditForm.ParseTime(self.resetData[2])
self.ui.startTime.setTime(QTime(h, m, s))
h, m, s = EditForm.ParseTime(self.resetData[3])
self.ui.endTime.setTime(QTime(h, m, s))
def monitorDataInit(myData, csvPath):
with open(csvPath, "r") as f:
for line in f:
try:
resultados = map(int, line.split(','))
t_ms = QTime().msecsTo(QTime(resultados[3], resultados[4], resultados[5]))
myData.update(t_ms, resultados[6], resultados[7], resultados[8], resultados[9], resultados[10])
except:
pass
def forceTime(val):
if isinstance(val, QVariant):
return val.toTime()
if isinstance(val, QTime):
return val
if isinstance(val, QDateTime):
return val.time()
if val is None:
return QTime()
return QTime(val)
def __init__(self, parent=None):
super(AnimationFrame, self).__init__(parent)
self.parent = parent
self.animationUI = Animation_menu.Ui_dockAnimationWidget()
self.animationUI.setupUi(self)
if iface and not iface.mainWindow().restoreDockWidget(self):
iface.mainWindow().addDockWidget(Qt.RightDockWidgetArea, self)
self.mapObject = None
self.addLayerMenu = None
self.animationUI.progressBar.hide()
self.animationUI.labelInfo.setText("")
self.animationUI.animationSlider.sliderMoved.connect(
self.onUserMovesSlider)
#We disable controller to avoid accidental inputs
self.animationUI.labelInfo.setEnabled(True)
#self.animationUI.animationSlider.setEnabled(False)
#self.animationUI.playButton.setEnabled(False)
self.animationUI.cancelButton.hide()
self.animationUI.addWCSButton.clicked.connect(
self._onAddWCSLayerButtonClicked)
self.animationUI.addWMSButton.clicked.connect(
self._onAddWMSLayerButtonClicked)
self.animationUI.addOtherButton.clicked.connect(
self._onAddOtherLayerButtonClicked)
self.animationUI.removeButton.clicked.connect(
self._removeLayerFromAnimation)
self.animationUI.cancelButton.clicked.connect(self._onCancelRequested)
self.animationUI.playButton.clicked.connect(self.play)
self.animationUI.buttonLoad.clicked.connect(self.prepareAnimation)
self.layerInfoList = []
self.animationUI.frameRateSpinbox.valueChanged.connect(
self._newFrameRateSelected)
self.animationUI.timeFrameVariation.timeChanged.connect(
self._timeVariationChanged)
self.animationUI.daysFrameVariation.valueChanged.connect(
self._timeVariationChanged)
self.animationUI.timeTolerance.timeChanged.connect(
self._toleranceChanged)
self.animationUI.daysTolerance.valueChanged.connect(
self._toleranceChanged)
self.initController()
self.animationUI.timeFrameVariation.setTime(QTime(1, 0, 0))
self._timeVariationChanged(QTime(1, 0, 0))
iface.addDockWidget(Qt.LeftDockWidgetArea, self)
def __init__(self, db, sql, parent=None):
self.db = db.connector
t = QTime()
t.start()
c = self.db._execute(None, unicode(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 main():
if settings.get('log:errors'):
log_filename = settings.get('log:filename')
if log_filename:
try:
log_file = open(log_filename, "w")
print('Redirecting stderr/stdout... to %s' % log_filename)
sys.stderr = log_file
sys.stdout = log_file
except IOError:
print "Lector could not open log file '%s'!\n" % log_filename \
+ " Redirecting will not work."
else:
print "Log file is not set. Pleaase set it in settings."
app = QApplication(sys.argv)
opts = [str(arg) for arg in app.arguments()[1:]]
if '--no-scanner' in opts:
scanner = False
else:
scanner = True
qsrand(QTime(0, 0, 0).secsTo(QTime.currentTime()))
locale = settings.get('ui:lang')
if not locale:
locale = QLocale.system().name()
qtTranslator = QTranslator()
if qtTranslator.load(":/translations/ts/lector_" + locale, 'ts'):
app.installTranslator(qtTranslator)
window = Window(scanner)
window.show()
app.exec_()
def setScoreTime(self):
self.ui.scoretable.repaint()
QApplication.processEvents()
try:
row = self.ui.scoretable.selectedIndexes()[0].row()
scoreStruct = self.scoreInfo["scoreStructs"][row]
time = scoreStruct.time
# Split string into date and time
time = str(time).split()
date = time[0].split('-')
year = str(date[0])
month = str(date[1])
day = str(date[2])
calendaradj = QDate(int(year), int(month), int(day))
self.ui.calendarWidget.setSelectedDate(calendaradj)
self.ui.timeEdit.setTime(QTime(int(time[1][:2]),
int(time[1][3:5])))
self.ui.startButton.setEnabled(True)
# User clicked a blank cell, stop here
except IndexError:
self.ui.statusText.setText("Error reading selected SCORE")
def __init__(self, parent=None):
""" Class constructor.
"""
super(EditForm, self).__init__(parent)
# UI setup
self.ui = Ui_Form()
self.ui.setupUi(self)
self.ui.saveButton.clicked.connect(self.HandleSaveButton)
self.ui.okButton.clicked.connect(self.HandleOkButton)
self.ui.resetButton.clicked.connect(self.HandleResetButton)
self.ui.deleteButton.clicked.connect(self.HandleDeleteButton)
self.ui.musicButton.clicked.connect(self.HandleMusicButton)
self.ui.saveFileButton.clicked.connect(self.HandleSaveFileButton)
self.ui.startTime.setDisplayFormat('hh:mm:ss')
self.ui.endTime.setDisplayFormat('hh:mm:ss')
self.ui.startTime.setMinimumTime(QTime(0, 0, 0))
# Class members
self.song = None
self.data = None
self.resetData = None
self.bitrate = None
self.name = None
self.result = None
self.index = None
self.isPlaying = False
def select_config(self, tablename):
""" Get data from table 'config' and fill widgets according to the name of the columns """
sql = "SELECT * FROM " + self.schema_name + "." + tablename
row = self.dao.get_row(sql)
if not row:
self.controller.show_warning("Any data found in table " + tablename)
return None
# Iterate over all columns and populate its corresponding widget
columns = []
for i in range(0, len(row)):
column_name = self.dao.get_column_name(i)
widget_type = utils_giswater.getWidgetType(column_name)
if widget_type is QCheckBox:
utils_giswater.setChecked(column_name, row[column_name])
elif widget_type is QDateEdit:
utils_giswater.setCalendarDate(column_name, datetime.strptime(row[column_name], '%Y-%m-%d'))
elif widget_type is QTimeEdit:
timeparts = str(row[column_name]).split(':')
if len(timeparts) < 3:
timeparts.append("0")
days = int(timeparts[0]) / 24
hours = int(timeparts[0]) % 24
minuts = int(timeparts[1])
seconds = int(timeparts[2])
time = QTime(hours, minuts, seconds)
utils_giswater.setTimeEdit(column_name, time)
utils_giswater.setText(column_name + "_day", days)
else:
utils_giswater.setWidgetText(column_name, row[column_name])
columns.append(column_name)
return columns
def formatValue(self, type_, v, upper):
util = FLUtil.FLUtil()
if self.driverName == "PGSql":
s = None
# TODO: psycopg2.mogrify ???
if type_ == "bool" or type_ == "unlock":
s = text2bool(v)
elif type_ == "date":
s = "'%s'" % util.dateDMAtoAMD(v)
elif type_ == "time":
time = QTime(s)
s = "'%s'" % time
elif type_ == "uint" or type_ == "int" or type_ == "double" or type_ == "serial":
s = v
else:
if upper == True and type_ == "string":
v = v.upper()
s = "'%s'" % v
#print ("PNSqlDriver.formatValue(%s, %s) = %s" % (type_, v, s))
return s
def getRecord(self, record):
dateTime = QDateTime(self.edtDate.date(), QTime().currentTime())
record.setValue('dateTime', dateTime)
i = self.cmbSocCodes.currentIndex()
socCode = forceString(self.cmbSocCodes.itemData(i))
record.setValue('socCode', socCode)
pregCard = forceInt(self.edtPregCard.text())
if pregCard > 0:
record.setValue('pregCard', pregCard)
else:
record.setNull('pregCard')
getRBComboBoxValue(self.cmbFinance, record, 'finance_id')
record.setValue('mkb', toVariant(self.cmbMKB.text()))
getRBComboBoxValue(self.cmbDrug, record, 'formularyItem_id')
getLineEditValue(self.edtDosage, record, 'dosage')
getSpinBoxValue(self.spbQnt, record, 'qnt')
getLineEditValue(self.edtSigna, record, 'signa')
getSpinBoxValue(self.spbDuration, record, 'duration')
getSpinBoxValue(self.spbNumPerDay, record, 'numPerDay')
record.setValue('isVk', int(self.rbtnVkYes.isChecked()))
record.setValue('printMnn', int(self.rbtnPrintMNN.isChecked()))
record.setValue('percentage',
int(50 if self.rbtn50proc.isChecked() else 100))
getComboBoxValue(self.cmbTerm, record, 'term')
record.setValue(
'status',
self.modelRecipeStatus.getCode(self.cmbStatus.currentIndex()))
record.setValue('deleted', 0)
def InitializeDates(phases, due_date, duration):
currentDate = due_date
for phase in phases[::-1]:
#enddate = currentDate-1
phase._enddate = currentDate - timedelta(days=1)
#iterate through phases until there's a match
if str(phase._idphases) in sharedDB.myPhases:
myPhase = sharedDB.myPhases[str(phase._idphases)]
#multiply duration(minutes) by _manHoursToMinuteRatio / work hours in a day
daysGoal = math.ceil(QTime().secsTo(duration) / 60.0 *
myPhase._manHoursToMinuteRatio / 8.0)
#print daysGoal
numdays = 0
#while numdays < work days
while numdays < daysGoal:
#subtract day from currentDate
currentDate = currentDate - timedelta(days=1)
#if workday
if currentDate.weekday() < 5:
numdays = numdays + 1
#phase start date = currentdate
phase._startdate = currentDate
return phases
def run(self):
time = QTime()
eventLoop = QEventLoop()
self.m_bStop = False
# log.debug("Запускаем поток")
#if not self.initThread():
#return
while not self.m_bStop:
self.m_nTactCounter += 1 # Добавить обнуление при переполнении
time.start()
eventLoop.processEvents()
if not self.workThread():
self.m_bStop = True
return
workTime = time.elapsed()
if 0 <= workTime < self.m_nTact:
self.msleep(self.m_nTact - workTime)
else:
self.msleep(0)
eventLoop.processEvents()
self.exitThread()
def __init__(self):
QThread.__init__(self)
self.running = False
self.scrollingTimer = QTimer()
self.scrollingTimer.setSingleShot(True)
self.scrollingTimer.timeout.connect(self.scrollEventStop)
self.time = QTime()
self.counter = 0
def slot_setEndNow(self):
time = int(
jacklib.get_current_transport_frame(self.fJackClient) /
self.fSampleRate)
secs = time % 60
mins = int(time / 60) % 60
hrs = int(time / 3600) % 60
self.ui.te_end.setTime(QTime(hrs, mins, secs))
def stateChanged(self, newState, oldState):
if newState == Phonon.ErrorState:
if self.__media_object.errorType() == Phonon.FatalError:
QMessageBox.warning(self.__main_window, "Fatal Error",
self.__media_object.errorString())
self.__media_object.setCurrentSource(self.__list_music[0])
self.__list_music.remove(self.__media_object.currentSource())
else:
QMessageBox.warning(self.__main_window, "Error",
self.__media_object.errorString())
self.__media_object.setCurrentSource(self.__list_music[0])
self.__list_music.remove(self.__media_object.currentSource())
elif newState == Phonon.PlayingState:
self.__main_window.getActionBar().get_widget(
'BTN_PLAY_PAUSE').setMStyle(MButton.Type.Pause)
self.__main_window.getActionBar().get_widget(
'BTN_PLAY_PAUSE').setToolTip('暂停')
self.__main_window.setSuspendStatus(False)
if self.__media_object.isSeekable():
self.__main_window.getActionBar().get_widget(
'SLD_SEEK').setCursor(Qt.PointingHandCursor)
self.__main_window.getActionBar().get_widget(
'INDICT_INFO').setText(self.__get_music_display_info())
time_total = self.__media_object.totalTime()
self.__main_window.getActionBar().get_widget(
'LBL_TIME_TOTAL').setText(
QTime(0, (time_total / 60000) % 60,
(time_total / 1000) % 60).toString('mm:ss'))
btn_music_stop = self.__main_window.getActionBar().get_widget(
'BTN_STOP')
if not btn_music_stop.isEnabled():
btn_music_stop.setEnabled(True)
self.__set_lyric(self.__media_object.currentSource().fileName())
elif newState == Phonon.StoppedState:
self.__main_window.getActionBar().get_widget('SLD_SEEK').setCursor(
Qt.ArrowCursor)
self.__main_window.getActionBar().get_widget(
'INDICT_INFO').setText(u'无音乐')
self.__main_window.getActionBar().get_widget(
'LBL_TIME_TOTAL').setText('00:00')
btn_music_stop = self.__main_window.getActionBar().get_widget(
'BTN_STOP')
if btn_music_stop.isEnabled():
btn_music_stop.setEnabled(False)
self.__lyric_panel.setNoLyric()
self.__main_window.getActionBar().get_widget(
'BTN_PLAY_PAUSE').setMStyle(MButton.Type.Play)
self.__main_window.getActionBar().get_widget(
'BTN_PLAY_PAUSE').setToolTip('播放')
self.__main_window.setSuspendStatus(True)
elif newState == Phonon.PausedState:
self.__main_window.getActionBar().get_widget(
'BTN_PLAY_PAUSE').setMStyle(MButton.Type.Play)
self.__main_window.getActionBar().get_widget(
'BTN_PLAY_PAUSE').setToolTip('播放')
self.__main_window.setSuspendStatus(True)
if newState != Phonon.StoppedState and newState != Phonon.PausedState:
return
def setTimeEdit(widget, time):
if type(widget) is str:
widget = _dialog.findChild(QWidget, widget)
if not widget:
return
if type(widget) is QTimeEdit:
if time is None:
time = QTime(00, 00, 00)
widget.setTime(time)
def _qgs_memory_layer(self, style, features=None):
""" Create QgsVectorLayer with memory backend and load
features into it """
result = QgsVectorLayer(style.parent.geometry_type, None, 'memory')
provider = result.dataProvider()
# Setup layer fields
fldmap = {}
for fld in style.parent.fields:
provider.addAttributes(
[QgsField(fld.keyname, *FIELD_TYPE_TO_QGIS[fld.datatype])])
fldmap[fld.keyname] = len(fldmap)
qgsfields = provider.fields()
result.updateFields()
# Load style from qml file
result.loadNamedStyle(self.env.file_storage.filename(
style.qml_fileobj))
# Disable read only flag when it was set via qml file
result.setReadOnly(False)
# Load features into layers if needed
if features is not None:
result.startEditing()
for feat in features:
qgsfeat = QgsFeature(qgsfields)
fattrs = [None] * len(fldmap)
for k, v in feat.fields.iteritems():
if v is None:
continue
elif isinstance(v, date):
v = QDate(v.year, v.month, v.day)
elif isinstance(v, time):
v = QTime(v.hour, v.minute, v.second)
elif isinstance(v, datetime):
v = QDateTime(v.year, v.month, v.day, v.hour, v.minute,
v.second)
fattrs[fldmap[k]] = v
qgsfeat.setAttributes(fattrs)
# Method fromWkb() is much faster constructor fromWkt()
# TODO: QGIS 3 have constructor fromWkb()
qgsgeom = QgsGeometry()
qgsgeom.fromWkb(feat.geom.wkb)
qgsfeat.setGeometry(qgsgeom)
result.addFeature(qgsfeat)
result.commitChanges()
result.setCrs(QgsCoordinateReferenceSystem(style.parent.srs.id))
return result
def export2gui(self):
"""Take data from program and fills GUI widget values."""
for entry in self._settings_data.values():
if entry.data_type == 'timedelta':
entry.gui_widget.setTime(
QTime(0,
entry.value.total_seconds() // 60,
entry.value.total_seconds() % 60))
else:
entry.gui_widget.setChecked(entry.value)
def timeEnd(self):
"""
Returns the ending time that will be used for this item. If it is an
all day event, then the time returned will be 23:59:59.
:return <QTime>
"""
if (self.isAllDay()):
return QTime(23, 59, 59)
return self._timeEnd
def setTimeEdit(dialog, widget, time):
if type(widget) is str or type(widget) is unicode:
widget = dialog.findChild(QWidget, widget)
if not widget:
return
if type(widget) is QTimeEdit:
if time is None:
time = QTime(0, 0, 0)
widget.setTime(time)
def timeStart(self):
"""
Returns the starting time that will be used for this item. If it is
an all day event, then the time returned will be 0:0:0
:return <QTime>
"""
if (self.isAllDay()):
return QTime(0, 0, 0)
return self._timeStart
def __init__(self, parent=None):
AbstractKeyboardMonitor.__init__(self, parent)
self._keyboard_was_active = False
self._old_keymap = array(b'B', b'\0' * 32)
self._keyboard_timer = QTimer(self)
self._keyboard_timer.timeout.connect(self._check_keyboard_activity)
self._keyboard_timer.setInterval(self.DEFAULT_POLLDELAY)
self._activity = QTime()
self._keys_to_ignore = self.IGNORE_NO_KEYS
self._keymap_mask = self._setup_mask()
self._idle_time = self.DEFAULT_IDLETIME
def forceDateTime(val):
if isinstance(val, QVariant):
return val.toDateTime()
if isinstance(val, QDateTime):
return val
if isinstance(val, QDate):
return QDateTime(val, QTime())
if isinstance(val, QTime):
return QDateTime(QDate(), val)
if val is None:
return QDateTime()
return QDateTime(val)
def testDateTimeFormats(self):
# check that date and time formats are correctly interpreted
basetestfile = os.path.join(TEST_DATA_DIR, 'tab_file.tab')
vl = QgsVectorLayer(u'{}|layerid=0'.format(basetestfile), u'test', u'ogr')
fields = vl.dataProvider().fields()
self.assertEqual(fields.at(fields.indexFromName('date')).type(), QVariant.Date)
self.assertEqual(fields.at(fields.indexFromName('time')).type(), QVariant.Time)
self.assertEqual(fields.at(fields.indexFromName('date_time')).type(), QVariant.DateTime)
f = vl.getFeatures(QgsFeatureRequest()).next()
date_idx = vl.fieldNameIndex('date')
assert isinstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2004, 5, 3))
time_idx = vl.fieldNameIndex('time')
assert isinstance(f.attributes()[time_idx], QTime)
self.assertEqual(f.attributes()[time_idx], QTime(13, 41, 00))
datetime_idx = vl.fieldNameIndex('date_time')
assert isinstance(f.attributes()[datetime_idx], QDateTime)
self.assertEqual(f.attributes()[datetime_idx], QDateTime(QDate(2004, 5, 3), QTime(13, 41, 00)))
