def test_session_widget_select_and_click_ok_changes_active_session(
session_widget):
with session_scope(session_widget.database) as s:
session = s.query(Session).first()
assert session_widget.session_id != session.session_id
session_widget.select_session(session_id=session.session_id)
assert session_widget.session_id == session.session_id
def onTransition(self, event: QEvent):
super().onTransition(event)
# Change active session
session_id = self.machine().s9.session_id
logger.debug(f'[{type(self).__name__}] Change active session to {session_id}')
with session_scope(self.database) as s:
session = s.query(Session).filter(Session.session_id == session_id).first()
self.machine().session = session
def onTransition(self, event: QEvent):
super().onTransition(event)
with session_scope(self.database) as s:
for e in self.machine().annotated_events:
logger.debug(f'Remove {str(e)} from database')
s.query(AnnotatedEvent).filter(
AnnotatedEvent.document_id == e.document_id
).filter(AnnotatedEvent.event_type == e.event_type).filter(
AnnotatedEvent.event_num == e.event_num
).delete()
def update_patients(self):
"""
Update patient list.
:return:
"""
self.select_widget.clear()
with session_scope(self.database) as session:
for patient in session.query(Patient).all():
self.select_widget.addItem(patient.patient_id)
def onTransition(self, event: QEvent):
super().onTransition(event)
logger.debug('Update document in database')
with session_scope(self.database) as s:
document = (
s.query(Document)
.filter(Document.document_id == self.document.document_id)
.first()
)
document.notes = self.document.notes
document.full_turn_count = self.document.full_turn_count
logger.debug(str(document))
def test_transition_from_initial_state_to_note_state_and_back_to_initial_state(machine):
pytest.helpers.transition_machine_to_s1(machine)
# Assign document
machine.document = machine.s2.create_document()
# Enter sensor info and document
machine.sensor.enter_info_to_database(machine.database)
machine.database.insert(machine.document)
# Generate and enter data
n = 10
time_s = list(range(n))
torque_Nm = list(range(n))
machine.document.insert_time_series(machine.database, time_s, torque_Nm)
# Trigger hidden transition from s1 to s6 (NoteState)
machine._s1_to_s6_signal.emit()
assert machine.in_state(machine.s6)
# Enter data
notes = 'pytest'
full_turn_count = 1
machine.s6.dialog.notes = notes
machine.s6.dialog.full_turn_count = full_turn_count
# Trigger transition from s6 to s7 (i.e., click Ok on NotesWindow)
machine.s6.signal_ok.emit()
app.processEvents()
# Trigger transition back to s6 (i.e., click No on "are you sure?" prompt)
machine.s7.signal_no.emit()
app.processEvents()
# Verify data is reset
assert machine.s6.dialog.notes == ''
assert machine.s6.dialog.full_turn_count == 0
machine.s6.dialog.notes = notes
machine.s6.dialog.full_turn_count = full_turn_count
# Trigger transition from s6 to s7 (i.e., click Ok on NotesWindow)
machine.s6.signal_ok.emit()
app.processEvents()
# Trigger transition from s7 to s1 (i.e., click Yes on "are you sure?" prompt)
machine.s7.signal_yes.emit()
app.processEvents()
assert machine.in_state(machine.s1)
# Verify that document updates were entered to database
with session_scope(machine.database) as s:
document = (
s.query(Document)
.filter(Document.document_id == machine.document.document_id)
.first()
)
assert document.notes == notes
assert float(document.full_turn_count) == full_turn_count
# Re-enter note state and verify that data have been reset
machine._s1_to_s6_signal.emit()
assert machine.in_state(machine.s6)
assert machine.s6.dialog.notes == ''
assert machine.s6.dialog.full_turn_count == 0
def onEntry(self, event: QEvent):
super().onEntry(event)
# Set default full turn count
event_count = len(self.document.get_related_events(self.database))
with session_scope(self.database) as s:
sensor_info = (s.query(SensorInfo).filter(
SensorInfo.sensor_serial_number ==
self.document.sensor_serial_number).first())
self.full_turn_count = event_count / float(
sensor_info.turns_in_full_turn)
logger.debug(
f'Calculate default full_turn_count = {self.full_turn_count} = '
f'{event_count} / {sensor_info.turns_in_full_turn}')
self.notes = ''
self.dialog.open()
def test_stop_measurement_pauses_producer_and_inserts_measurements_to_database(machine):
pytest.helpers.transition_machine_to_s1(machine)
# start measurement for 2 seconds
machine.main_window.measurement_widget.start_button.clicked.emit()
time.sleep(2)
app.processEvents()
# stop measurement
machine.main_window.measurement_widget.stop_button.clicked.emit()
app.processEvents()
assert machine.producer_process.is_alive()
with session_scope(machine.database) as s:
measurements = (
s.query(Measurement)
.filter(Measurement.document_id == machine.document.document_id)
.all()
)
assert len(measurements) > 0
def update_sessions(self):
"""
Update session list.
:return:
"""
# Clear current contents
self.sessions = []
self.table_widget.clear()
# Add new contents
with session_scope(self.database) as s:
for i, session in enumerate(s.query(Session).all()):
self.sessions.append(session)
self.table_widget.setRowCount(i + 1)
self.table_widget.setItem(i, 0, QTableWidgetItem(session.session_id))
self.table_widget.setItem(
i, 1, QTableWidgetItem(str(session.started_at))
)
def test_start_measurement_inserts_document_and_sensor_info_to_database(machine):
pytest.helpers.transition_machine_to_s1(machine)
# Start measurement
machine.main_window.measurement_widget.start_button.clicked.emit()
app.processEvents()
assert machine.document is not None
with session_scope(machine.database) as s:
document = s.query(Document).first()
assert document.document_id == machine.document.document_id
# Verify patient, distractor and operator
assert document.patient_id == machine.patient_id
assert document.distractor_number == machine.distractor
assert document.operator == machine.operator
assert document.sensor_serial_number
sensor_info = (
s.query(SensorInfo)
.filter(SensorInfo.sensor_serial_number == document.sensor_serial_number)
.all()
)
assert len(sensor_info) == 1
#!/usr/bin/env python
import argparse
import pandas as pd
from pathlib import Path
from cranio.model import Database, session_scope, Base, Measurement
from cranio.utils import logger, configure_logging
parser = argparse.ArgumentParser()
parser.add_argument('path', help='Path to SQLite file (.db)', type=str)
if __name__ == '__main__':
configure_logging()
args = parser.parse_args()
path = Path(args.path)
database = Database(drivername='sqlite', database=str(path))
database.create_engine()
with session_scope(database) as s:
for table_name, table in Base.metadata.tables.items():
path_out = path.parent / (table_name + '.csv')
logger.info(f'Read table {table_name} from {database.url} to {path_out}')
df = pd.read_sql_table(table_name, con=database.engine)
df.to_csv(path_out, sep=';', index=False)
def test_event_detection_state_flow(machine, qtbot):
pytest.helpers.transition_machine_to_s1(machine)
# Assign document
machine.document = machine.s2.create_document()
# Enter sensor info and document
machine.sensor.enter_info_to_database(machine.database)
machine.database.insert(machine.document)
# Generate and enter data
n = 10
time_s = list(range(n))
torque_Nm = list(range(n))
machine.document.insert_time_series(machine.database, time_s, torque_Nm)
# Trigger hidden transition from s1 to s3 (EventDetectionState)
machine._s1_to_s3_signal.emit()
app.processEvents()
# Note that regions (sensor_info.turns_in_full_turn) are created on state entry
region_count = machine.s3.region_count()
# Remove regions
machine.s3.dialog.clear_regions()
machine.s3.dialog.set_add_count(0)
assert machine.s3.region_count() == 0
region_count = 2
# Increase region count by up arrow press
for i in range(region_count):
with qtbot.waitSignal(machine.s3.signal_value_changed):
qtbot.keyPress(machine.s3.dialog, Qt.Key_Up)
assert machine.s3.dialog.get_add_count() == i + 1
# Decrease region count by down arrow press
for i in reversed(range(region_count)):
with qtbot.waitSignal(machine.s3.signal_value_changed):
qtbot.keyPress(machine.s3.dialog, Qt.Key_Down)
assert machine.s3.dialog.get_add_count() == i
# Set correct add count
machine.s3.dialog.set_add_count(region_count)
# No existing regions -> press enter clicks Add
with qtbot.waitSignal(machine.s3.signal_add):
qtbot.keyPress(machine.s3.dialog, Qt.Key_Enter)
assert machine.s3.region_count() == region_count
logger.debug('Regions added and asserted')
# Regions exist -> press enter clicks Ok
with qtbot.waitSignal(machine.s3.signal_ok):
qtbot.keyPress(machine.s3.dialog, Qt.Key_Enter)
assert machine.in_state(machine.s6)
# Verify that annotated events were entered
with session_scope(machine.database) as s:
events = (
s.query(AnnotatedEvent)
.filter(AnnotatedEvent.document_id == machine.document.document_id)
.all()
)
assert len(events) == region_count
region_edits = [
machine.s3.dialog.get_region_edit(i) for i in range(region_count)
]
# Verify region edges
for region_edit, event in zip(region_edits, events):
assert region_edit.left_edge() == event.event_begin
assert region_edit.right_edge() == event.event_end
# Trigger transition back to s3 and verify that annotated events were removed
machine.s6.signal_close.emit()
assert machine.in_state(machine.s3)
# Trigger transition back to s6
with qtbot.waitSignal(machine.s3.signal_ok):
qtbot.keyPress(machine.s3.dialog, Qt.Key_Enter)
assert machine.in_state(machine.s6)
# Trigger transition from s6 to s7 (i.e., click Ok on NotesWindow)
machine.s6.signal_ok.emit()
app.processEvents()
# Trigger transition back to s6 (i.e., click No on "are you sure?" prompt)
machine.s7.signal_no.emit()
app.processEvents()
# Enter data in NotesWindow
notes = 'foo'
full_turn_count = 1.2
machine.s6.dialog.notes = notes
machine.s6.dialog.full_turn_count = full_turn_count
# Trigger transition from s6 to s7 (i.e., click Ok on NotesWindow)
machine.s6.signal_ok.emit()
app.processEvents()
# Trigger transition from s7 to s1 (i.e., click Yes on "are you sure?" prompt)
machine.s7.signal_yes.emit()
app.processEvents()
# Verify that document updates were entered to database
with session_scope(machine.database) as s:
document = (
s.query(Document)
.filter(Document.document_id == machine.document.document_id)
.first()
)
assert document.notes == notes
assert float(document.full_turn_count) == full_turn_count