def fill_table(self):
"""adds test names to the table"""
mgr = self.session.test_manager
for name in mgr.tests.keys():
row = self.table.rowCount()
self.table.insertRow(row)
test_name = QTableWidgetItem()
test_name.setData(Qt.DisplayRole, name)
self.table.setItem(row, 0, test_name)
def item_changed(self, Qitem: QTableWidgetItem):
if not Qitem.text() or Qitem.column() == 0:
return
try:
int(Qitem.text())
except ValueError:
Msgbox = QMessageBox()
Msgbox.setText("Error, Pixel ID must be an integer!")
Msgbox.exec()
Qitem.setData(Qt.DisplayRole, None)
def UpdateTableRow(self, i, miim, row):
self.ui.tableWidget.insertRow(self.ui.tableWidget.rowCount())
for j, v in enumerate(row):
if j == 0:
self.data_array.append(v)
elif j == 3:
self.login_array.append(v)
it = QTableWidgetItem()
it.setData(Qt.DisplayRole, v)
self.ui.tableWidget.setItem((i - miim), j, it)
def renewal(self):
self.table.clearContents()
self.table.setRowCount(0)
for row_index, row in enumerate(self.fetch()):
self.table.insertRow(row_index)
id, *row_data = row
for column_index, item in enumerate(row_data):
item = QTableWidgetItem(str(item) if item is not None else '')
item.setData(Qt.UserRole, id)
self.table.setItem(row_index, column_index, QTableWidgetItem(item))
def load_table(self):
for spent_limit in self.__standard_spent_limit:
initial_row_count = self.ui.tableWidget.rowCount()
self.ui.tableWidget.insertRow(initial_row_count)
#create and insert QTableWidgetItems
twi_category = QTableWidgetItem()
twi_category.setData(Qt.DisplayRole, spent_limit.category.name)
twi_category.setFlags(Qt.ItemIsEnabled) # Disable for edition
self.ui.tableWidget.setItem(initial_row_count, 0, twi_category)
twi_amount = QTableWidgetItem()
twi_amount.setData(Qt.DisplayRole, spent_limit.amount)
self.ui.tableWidget.setItem(initial_row_count, 1, twi_amount)
def load_spent_table(self):
if (len(self.__spent_in_month.spent_list) < 50):
number_of_line = 50
else:
number_of_line = len(self.__spent_in_month.spent_list)
self.ui.tableWidget_spent.setRowCount(number_of_line)
while (len(self.__spent_in_month.spent_list) < number_of_line):
new_spent = Spent()
self.__spent_in_month.spent_list.append(new_spent)
current_row = 0
# create delegates:
cbd = CategoryComboBoxItemDelegate(self.__spent_categories,
self.ui.tableWidget_spent)
self.ui.tableWidget_spent.setItemDelegateForColumn(3, cbd)
double_delegate = DoubleDelegate(self.ui.tableWidget_spent)
self.ui.tableWidget_spent.setItemDelegateForColumn(1, double_delegate)
dimd = DayInMonthDelegate(self.ui.tableWidget_spent)
self.ui.tableWidget_spent.setItemDelegateForColumn(0, dimd)
for spent in self.__spent_in_month.spent_list:
twi_how_day = QTableWidgetItem()
twi_how_day.setData(Qt.DisplayRole, spent.day_in_month)
self.ui.tableWidget_spent.setItem(current_row, 0, twi_how_day)
twi_how_much = QTableWidgetItem()
twi_how_much.setData(Qt.DisplayRole, spent.how_much)
self.ui.tableWidget_spent.setItem(current_row, 1, twi_how_much)
twi_where = QTableWidgetItem()
twi_where.setData(Qt.DisplayRole, spent.where)
self.ui.tableWidget_spent.setItem(current_row, 2, twi_where)
twi_category = QTableWidgetItem()
if (spent.category != None): # just fill if has been initialized
twi_category.setData(Qt.DisplayRole, spent.category.name)
self.ui.tableWidget_spent.setItem(current_row, 3, twi_category)
current_row += 1
def add_action(self, action_name):
row = self.actionTableWidget.rowCount()
self.actionTableWidget.insertRow(row)
item = QTableWidgetItem()
item.setText(str(action_name))
item.setData(Qt.UserRole, None)
self.actionTableWidget.setItem(row, 0, item)
#add button
self.actionTableWidget.setItem(row, 1, QTableWidgetItem())
button = QPushButton()
button.setText("Add Constraint")
self.actionTableWidget.setCellWidget(row, 1, button)
func = partial(self.set_constraint_in_row, row)
button.clicked.connect(func)
return item
def _fill_off_geometry_pixel_mapping(self, shape: OFFGeometryNexus):
"""
Fill in the pixel mapping information from an OFFGeometry component.
:param shape: The shape data from the NeXus file.
"""
# Retrieve the detector face information from the shape and use this to create the required number of pixel
# mapping widgets
n_faces, detector_faces = self._get_detector_face_information(shape)
self.create_pixel_mapping_table(n_faces, "face")
# Populate the pixel mapping widgets based on the contents of the detector_faces array
for detector_face in detector_faces:
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, detector_face[1])
self.pixel_mapping_table_widget.setItem(detector_face[0], 1,
QTableWidgetItem(item))
def show_query_resluts(self, header: list, rows: list) -> None:
self.wrapped_table.setColumnCount(len(header))
self.wrapped_table.setRowCount(len(rows))
for i, c_name in enumerate(header):
self.wrapped_table.setHorizontalHeaderItem(
i, QTableWidgetItem(c_name))
for i, row in enumerate(rows):
for j, value in enumerate(row):
item = QTableWidgetItem()
item.setData(0, value)
if item.text() == "":
item.setText(str(
value)) # use str representation for unsupported types
self.wrapped_table.setItem(i, j, item)
def serch_Data(self):
self.locker()
if self.login_array != []:
self.login_array.clear()
if self.chek:
enter = self.ui.dateTimeEdit.text()
enter = enter.split(' ')
age = enter[0]
clock = enter[1]
age = age.split('.')
clock = clock.split(':')
unix_time = datetime.datetime(int(age[2]),
int(age[1]), int(age[0]),
int(clock[0]), int(clock[1]),
int(clock[2])).timestamp()
unix_time = int(unix_time)
unix_time = str(unix_time)
if unix_time in self.data_array:
self.data_array.clear()
self.ui.tableWidget.setRowCount(0)
self.UpdateTableHeader(self.save_array[0])
p = 0
value = 0
max = len(self.save_array[1:])
step = 100 / max
for row in self.save_array[1:]:
value += step
self.callback_obj.progressBarUpdated.emit(value)
if row[0] <= unix_time <= row[1]:
self.ui.tableWidget.insertRow(
self.ui.tableWidget.rowCount())
for j, v in enumerate(row):
if j == 3:
self.login_array.append(v)
it = QTableWidgetItem()
it.setData(Qt.DisplayRole, v)
self.ui.tableWidget.setItem(p, j, it)
p += 1
self.callback_obj.progressBarUpdated.emit(0)
self.unlocker()
pass
else:
QMessageBox.about(self, 'Ошибка', 'Дата не найдена')
self.unlocker()
else:
QMessageBox.about(self, 'Ошибка', 'Проанализируйте файл')
self.unlocker()
def create_pixel_mapping_table(self, n_items: int, text: str):
"""
Creates a table of pixel mapping widgets.
:param n_items: The number of widgets to create.
:param text: The label to be displayed next to the id cel.
This is either faces or cylinders.
"""
self.reset_pixel_mapping_table()
self.pixel_mapping_table_widget.setColumnCount(2)
self.pixel_mapping_table_widget.setRowCount(n_items)
for i in range(n_items):
col_text = f"Pixel ID for {text} #{i}:"
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, col_text)
self.pixel_mapping_table_widget.setItem(i, 0, item)
self.pixel_mapping_table_widget.resizeColumnToContents(0)
self.pixel_mapping_table_widget.itemChanged.connect(
self.update_pixel_mapping_validity)
def btn_add(self):
self.ui.tableWidget_today.insertRow(0)
today_date = datetime.date.today()
today_date_as_QDate = QDate(today_date.year, today_date.month,
today_date.day)
twi_date = QTableWidgetItem() # add QTableWidgetItem in first column
self.ui.tableWidget_today.setItem(0, 0, twi_date)
twi_date.setData(Qt.DisplayRole, today_date_as_QDate)
for j in range(1, self.ui.tableWidget_today.columnCount()):
twi = QTableWidgetItem()
self.ui.tableWidget_today.setItem(0, j, twi)
if (j - 1 < len(self.__asset_categories)
): # just add AssetsInMonth for non deleted Categories
new_asset_in_month = AssetsInMonth()
new_asset_in_month.set_checked_day_as_datetime(today_date)
new_asset_in_month.set_category(self.__asset_categories[j - 1])
self.__assets_in_dates_list.append(new_asset_in_month)
else:
twi.setFlags(Qt.ItemIsEnabled) # Disable for edition
def load_income_table(self):
if (len(self.__spent_in_month.revenue_forecast) < 10):
number_of_line = 10
else:
number_of_line = len(self.__spent_in_month.revenue_forecast)
self.ui.tableWidget_income.setRowCount(number_of_line)
while (len(self.__spent_in_month.revenue_forecast) < number_of_line):
new_revenue = RevenueForecast()
self.__spent_in_month.revenue_forecast.append(new_revenue)
current_row = 0
# create delegates:
double_delegate = DoubleDelegate(self.ui.tableWidget_income)
self.ui.tableWidget_income.setItemDelegateForColumn(1, double_delegate)
dimd = DayInMonthDelegate(self.ui.tableWidget_income)
self.ui.tableWidget_income.setItemDelegateForColumn(2, dimd)
for income in self.__spent_in_month.revenue_forecast:
twi_what = QTableWidgetItem()
twi_what.setData(Qt.DisplayRole, income.what)
self.ui.tableWidget_income.setItem(current_row, 0, twi_what)
twi_how_much = QTableWidgetItem()
twi_how_much.setData(Qt.DisplayRole, income.how_much)
self.ui.tableWidget_income.setItem(current_row, 1, twi_how_much)
twi_how_day = QTableWidgetItem()
twi_how_day.setData(Qt.DisplayRole, income.day_in_month)
self.ui.tableWidget_income.setItem(current_row, 2, twi_how_day)
current_row += 1
def serch_Login(self):
self.locker()
if self.data_array != []:
self.data_array.clear()
if self.chek:
login, ok = QInputDialog.getText(self, "Ввод логина",
"Введите логин для поиска:",
QLineEdit.Normal, '')
if ok and login:
if login in self.login_array:
self.login_array.clear()
p = 0
value = 0
max = len(self.save_array[1:])
step = 100 / max
for row in self.save_array[1:]:
value += step
self.callback_obj.progressBarUpdated.emit(value)
if login in row:
self.ui.tableWidget.insertRow(
self.ui.tableWidget.rowCount())
for j, v in enumerate(row):
if j == 0:
self.data_array.append(v)
it = QTableWidgetItem()
it.setData(Qt.DisplayRole, v)
self.ui.tableWidget.setItem(p, j, it)
p += 1
self.callback_obj.progressBarUpdated.emit(0)
self.unlocker()
else:
QMessageBox.about(self, 'Ошибка', 'Логина не найдено.')
self.unlocker()
else:
QMessageBox.about(self, 'Ошибка', 'Введите логин.')
self.unlocker()
else:
QMessageBox.about(self, 'Ошибка', 'Проанализируйте файл.')
self.unlocker()
def _fill_entire_shape_fields(self, component_to_edit: Component):
"""
Fill the "entire shape" fields a component that is being edited and contains pixel data.
:param component_to_edit: The component being edited.
"""
shape = component_to_edit.shape[0]
if isinstance(shape, OFFGeometryNexus):
self._fill_off_geometry_pixel_mapping(shape)
elif not isinstance(shape, BoxGeometry):
detector_number = shape.detector_number
n_cylinders = shape.cylinders.size // 3
if n_cylinders > 1:
self.create_pixel_mapping_table(n_cylinders, "cylinder")
# TODO: Restore pixel mapping in the case of multiple cylinders
else:
self.create_pixel_mapping_table(n_cylinders, "cylinder")
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, detector_number[0])
self.pixel_mapping_table_widget.setItem(0, 1, item)
def load_sum_table(self):
self.check_new_categories_for_spent_limit()
for spent_limit in self.__spent_in_month.spent_limit_goal:
initial_row_count = self.ui.tableWidget_sum.rowCount()
self.ui.tableWidget_sum.insertRow(initial_row_count)
#create and insert QTableWidgetItems
twi_category = QTableWidgetItem()
twi_category.setData(Qt.DisplayRole, spent_limit.category.name)
twi_category.setFlags(Qt.ItemIsEnabled) # Disable for edition
self.ui.tableWidget_sum.setItem(initial_row_count, 0, twi_category)
twi_sum = QTableWidgetItem()
# twi_sum.setData(Qt.DisplayRole, spent_limit.category.name)
twi_sum.setFlags(Qt.ItemIsEnabled) # Disable for edition
self.ui.tableWidget_sum.setItem(initial_row_count, 1, twi_sum)
twi_goal = QTableWidgetItem()
bold_font = QFont()
bold_font.setBold(True)
twi_goal.setFont(bold_font)
twi_goal.setData(Qt.DisplayRole, spent_limit.amount)
self.ui.tableWidget_sum.setItem(initial_row_count, 2, twi_goal)
self.update_spent_sum()
self.update_all_colors_sum_table()
def add_constraint_to_table(self, frame_idx, joint_name, constraint_name):
row = self.constraintsTableWidget.rowCount()
self.constraintsTableWidget.insertRow(row)
item0 = QTableWidgetItem()
item0.setText(str(frame_idx))
item0.setData(Qt.UserRole, None)
self.constraintsTableWidget.setItem(row, 0, item0)
item1 = QTableWidgetItem()
item1.setText(str(joint_name))
item1.setData(Qt.UserRole, None)
self.constraintsTableWidget.setItem(row, 1, item1)
item2 = QTableWidgetItem()
item2.setText(str(constraint_name))
item2.setData(Qt.UserRole, None)
self.constraintsTableWidget.setItem(row, 2, item2)
def load_spent_table(self):
number_of_line = 10
self.ui.tableWidget_spent.setRowCount(number_of_line)
while (len(self.__year_predictions._spent_list) < number_of_line):
new_value_in_year = ValuesInYear()
self.__year_predictions._spent_list.append(new_value_in_year)
current_row = 0
for value_in_year in self.__year_predictions._spent_list:
twi_where = QTableWidgetItem()
twi_where.setData(Qt.DisplayRole, value_in_year.where)
self.ui.tableWidget_spent.setItem(current_row, 0, twi_where)
twi_how_much = QTableWidgetItem()
twi_how_much.setData(Qt.DisplayRole, value_in_year.how_much)
self.ui.tableWidget_spent.setItem(current_row, 1, twi_how_much)
twi_how_parcels = QTableWidgetItem()
twi_how_parcels.setData(Qt.DisplayRole, value_in_year.parcels)
self.ui.tableWidget_spent.setItem(current_row, 2, twi_how_parcels)
twi_sum = QTableWidgetItem()
twi_sum.setFlags(Qt.ItemIsEnabled) # Disable for edition
self.ui.tableWidget_spent.setItem(current_row, 3, twi_sum)
current_row += 1
def _add_record_view(self, record: PatientBoneAgeRecord):
row = self.rowCount()
self.insertRow(row)
self._records_rows[record] = row
name = '' if record.image is None else record.image.path.stem
name_item = QTableWidgetItem(name)
name_item.setTextAlignment(Qt.AlignCenter)
# Add the |record| reference to the |name_item|
name_item.setData(TableItemDataRole.RECORD_REF, record)
self.setItem(row, self.column_number(TableNameColumn), name_item)
gender_widget = GenderWidget(embedded=True)
gender_widget.man = record.male
gender_widget.gender_changed.connect(
partial(self._on_gender_changed, record))
record.male_changed.connect(
partial(self._on_record_male_changed, gender_widget))
self.setCellWidget(row, self.column_number(TableGenderColumn),
gender_widget)
birthdate_edit_widget = DateEditWidget(record.birthdate, embedded=True)
birthdate_edit_widget.dateChanged.connect(
partial(self._on_birthdate_changed, record))
self.setCellWidget(row, self.column_number(TableBirthdateColumn),
birthdate_edit_widget)
image_date_edit_widget = DateEditWidget(record.image_date,
embedded=True)
image_date_edit_widget.dateChanged.connect(
partial(self._on_image_date_changed, record))
self.setCellWidget(row, self.column_number(TableImageDateColumn),
image_date_edit_widget)
age_in_image_item = QTableWidgetItem()
age_in_image_item.setFlags(age_in_image_item.flags()
& ~Qt.ItemIsEditable)
age_in_image_item.setTextAlignment(Qt.AlignCenter)
record.age_in_image_changed.connect(
partial(self._set_age_to_table_item, age_in_image_item))
self.setItem(row, self.column_number(TableAgeInImageColumn),
age_in_image_item)
bone_age_item = QTableWidgetItem()
bone_age_item.setFlags(bone_age_item.flags() & ~Qt.ItemIsEditable)
record.bone_age_changed.connect(
partial(self._set_age_to_table_item, bone_age_item))
record.skeletal_development_rate_changed.connect(
partial(self._on_skeletal_development_rate_changed, record))
self.setItem(row, self.column_number(TableDenseNetBoneAgeColumn),
bone_age_item)
self._update_bone_age_table_item_foreground(record)
height_spin_box = QDoubleSpinBox()
height_spin_box.setAlignment(Qt.AlignCenter)
height_spin_box.setFrame(False)
height_spin_box.setDecimals(1)
height_spin_box.setMaximum(300)
self._set_height_to_table_item_widget(height_spin_box, record.height)
record.height_changed.connect(
partial(self._set_height_to_table_item_widget, height_spin_box))
height_spin_box.valueChanged.connect(
partial(self._on_height_table_item_widget_value_changed, record))
self.setCellWidget(row, self.column_number(TableHeightColumn),
height_spin_box)
max_height_item = QTableWidgetItem()
max_height_item.setFlags(max_height_item.flags() & ~Qt.ItemIsEditable)
max_height_item.setTextAlignment(Qt.AlignCenter)
self._set_max_height_to_table_item(max_height_item, record.max_height)
record.max_height_changed.connect(
partial(self._set_max_height_to_table_item, max_height_item))
self.setItem(row, self.column_number(TableMaxHeightColumn),
max_height_item)
self._update_age_column_contents_for_row(row)
async def validateUrl(self, url: str) -> bool:
self.download.setDisabled(True)
self.files.setDisabled(True)
self.files.clearSelection()
self.files.clearFocus()
self.files.clearContents()
self.files.setRowCount(0)
self.files.setSortingEnabled(False)
self.url.setStyleSheet('')
self.modId = 0
if not url:
self.urlInfo.setText('''
<font color="#888">Please enter a valid mod url.</font>
''')
return False
modId = getModId(url)
if not modId:
self.files.setDisabled(True)
self.url.setStyleSheet('''
*{
border: 1px solid #B22222;
padding: 1px 0px;
}
''')
self.urlInfo.setText('''
<font color="#888">Please enter a valid mod url.</font>
''')
return False
self.urlInfo.setText('🌐')
try:
filesResponse = await getModFiles(modId)
except (RequestError, ResponseError, Exception) as e:
self.url.setStyleSheet('''
*{
border: 1px solid #B22222;
padding: 1px 0px;
}
''')
self.urlInfo.setText(f'''
<font color="#888">Could not get mod files: {e}.</font>
''')
return False
try:
files = filesResponse['files']
if not len(files):
self.urlInfo.setText(f'''
<font color="#888">Mod "{modId}" has no files!</font>
''')
return False
self.files.setRowCount(len(files))
for i in range(len(files)):
file = files[i]
fileid = int(file['file_id'])
name = str(file['name'])
version = str(file['version'])
_uploadtime = dateparser.parse(file['uploaded_time'])
uploadtime = _uploadtime.astimezone(tz=None).strftime(
'%Y-%m-%d %H:%M:%S') if _uploadtime else '?'
description = html.unescape(str(file['description']))
nameItem = QTableWidgetItem(name)
nameItem.setToolTip(name)
nameItem.setData(Qt.UserRole, fileid)
self.files.setItem(i, 0, nameItem)
versionItem = QTableWidgetItem(version)
versionItem.setToolTip(version)
self.files.setItem(i, 1, versionItem)
uploadtimeItem = QTableWidgetItem(uploadtime)
uploadtimeItem.setToolTip(uploadtime)
self.files.setItem(i, 2, uploadtimeItem)
descriptionItem = QTableWidgetItem(description)
descriptionItem.setToolTip(description)
self.files.setItem(i, 3, descriptionItem)
except KeyError as e:
logger.exception(
f'Could not find key "{str(e)}" in mod files response')
self.urlInfo.setText(f'''
<font color="#888">Could not find key "{str(e)}" in mod files response.</font>
''')
return False
self.urlInfo.setText(f'''
<font color="#888">Found {len(files)} available files.</font>
''')
self.files.resizeColumnsToContents()
self.files.setDisabled(False)
self.files.setSortingEnabled(True)
self.modId = modId
return True
def UpdateTableRow(self, i, miim, row):
self.ui.tableWidget.insertRow(self.ui.tableWidget.rowCount())
for j, v in enumerate(row):
it = QTableWidgetItem()
it.setData(Qt.DisplayRole, v)
self.ui.tableWidget.setItem((i - miim), j, it)
app = QApplication(sys.argv)
# Create and populate the tableWidget
tableWidget = QTableWidget(4, 4)
tableWidget.setItemDelegate(StarDelegate())
tableWidget.setEditTriggers(QAbstractItemView.DoubleClicked
| QAbstractItemView.SelectedClicked)
tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
tableWidget.setHorizontalHeaderLabels(
["Title", "Genre", "Artist", "Rating"])
data = [["Mass in B-Minor", "Baroque", "J.S. Bach", 5],
["Three More Foxes", "Jazz", "Maynard Ferguson", 4],
["Sex Bomb", "Pop", "Tom Jones", 3],
["Barbie Girl", "Pop", "Aqua", 5]]
for r in range(len(data)):
tableWidget.setItem(r, 0, QTableWidgetItem(data[r][0]))
tableWidget.setItem(r, 1, QTableWidgetItem(data[r][1]))
tableWidget.setItem(r, 2, QTableWidgetItem(data[r][2]))
item = QTableWidgetItem()
item.setData(0, StarRating(data[r][3]).starCount)
tableWidget.setItem(r, 3, item)
tableWidget.resizeColumnsToContents()
tableWidget.resize(500, 300)
tableWidget.show()
sys.exit(app.exec_())
def update_list(self):
self.table_widget.clear()
self.table_widget.setHorizontalHeaderLabels([
"Name", "State", "Players", "Password?", "Creator", "Creation Date"
])
name_filter = self.filter_name_edit.text().strip()
displayed_has_password = set()
if self.has_password_yes_check.isChecked():
displayed_has_password.add(True)
if self.has_password_no_check.isChecked():
displayed_has_password.add(False)
displayed_states = set()
for (check, state) in ((self.state_setup_check,
GameSessionState.SETUP),
(self.state_inprogress_check,
GameSessionState.IN_PROGRESS),
(self.state_finished_check,
GameSessionState.FINISHED)):
if check.isChecked():
displayed_states.add(state)
dont_filter_age = not self.filter_age_check.isChecked()
now = datetime.datetime.now(tz=datetime.timezone.utc)
max_session_age = datetime.timedelta(days=self.filter_age_spin.value())
visible_sessions = [
session for session in reversed(self.sessions)
if (session.has_password in displayed_has_password and session.
state in displayed_states and name_filter in session.name and (
dont_filter_age or
(now - session.creation_date) < max_session_age))
]
self.visible_sessions = visible_sessions
self.table_widget.setRowCount(len(visible_sessions))
for i, session in enumerate(visible_sessions):
name = QTableWidgetItem(session.name)
state = QTableWidgetItem(session.state.user_friendly_name)
players_item = QTableWidgetItem(str(session.num_players))
has_password = QTableWidgetItem(
"Yes" if session.has_password else "No")
creator = QTableWidgetItem(session.creator)
creation_date = QTableWidgetItem(
session.creation_date.astimezone().strftime("%Y-%m-%d %H:%M"))
name.setData(Qt.UserRole, session)
self.table_widget.setItem(i, 0, name)
self.table_widget.setItem(i, 1, state)
self.table_widget.setItem(i, 2, players_item)
self.table_widget.setItem(i, 3, has_password)
self.table_widget.setItem(i, 4, creator)
self.table_widget.setItem(i, 5, creation_date)
for i in range(6):
self.table_widget.resizeColumnToContents(i)
self.status_label.setText(
f"{len(self.sessions)} sessions total, {len(visible_sessions)} displayed."
)
def getItem(text):
item = QTableWidgetItem(text)
item.setData(Qt.UserRole, actuatorId)
return item
