def _get_settings(config_dir=None):
"""
配置文件
"""
if config_dir is None:
config_dir = os.path.join(os.path.abspath(os.path.curdir),
"wallet_config")
if not os.path.exists(config_dir):
os.makedirs(config_dir)
config_file = os.path.join(config_dir, "config.ini")
settings_obj = QSettings(config_file, QSettings.IniFormat)
settings_obj.setIniCodec(QTextCodec.codecForName("utf-8"))
if settings_obj.value(Configs.db_used) is None:
settings_obj.setValue(Configs.db_used, DBField.db_type[0])
if settings_obj.value(Configs.db_path) is None:
settings_obj.setValue(
Configs.db_path,
os.path.abspath(os.path.join("./", Configs.default_db_name)))
return settings_obj
def __init__(self, parent=None):
super().__init__(parent=parent)
self.running: bool = True
self.skip_update: bool = False
self.client = Client(method='rtu',
port='COM3',
timeout=0.05,
baudrate=115200,
retry_on_empty=True,
retries=5,
strict=False)
self.ai: MV110_8AC = MV110_8AC(client=self.client, unit=1)
settings = QSettings('manometers.ini', QSettings.IniFormat)
settings.setIniCodec('UTF-8')
manometers = [
settings.value('ppm', (0, 1.6)),
settings.value('pim', (0, 1.0)),
settings.value('ptc1', (0, 1.0)),
settings.value('ptc2', (0, 1.0)),
settings.value('pupr', (0, 1.0)),
]
for i, v in enumerate(manometers):
self.ai.pin[i].eu_range = Range(float(manometers[i][0]),
float(manometers[i][1]))
self.di: MV_DI = MV110_32DN(client=self.client, unit=2)
class Settings(object):
CORE = "core"
LANGUAGES = CORE + "/languages"
ENCODING = CORE + "/encoding"
WINDOW = "window"
WINDOW_GEOMETRY = WINDOW + "/geometry"
WINDOW_STATE = WINDOW + "/state"
def __init__(self):
super().__init__()
self._settings = QSettings()
self._settings.setIniCodec('UTF-8')
logger.debug("Settings file: '{}'".format(self._settings.fileName()))
def get(self, name: str) -> Any:
try:
value = self._settings.value(name)
except Exception as e:
logger.warn(f"Error getting setting '{name}': {e}")
return value
def set(self, name: str, value: Any):
try:
self._settings.setValue(name, value)
except Exception as e:
logger.warn(f"Error setting setting '{name}' to '{value}': {e}")
class MainWidget(QWidget):
def __init__(
self,
parent,
):
super(QWidget, self).__init__(parent)
self.layout = QVBoxLayout(self)
self.ini = QSettings(SETTINGS_PATH, QSettings.IniFormat)
self.ini.setIniCodec("utf-8")
# tabs for application
self.tabs = QTabWidget()
self.mainTab = ConnectionPanel(settings=SETTINGS_PATH)
self.serversTab = ServersTable(settings=SETTINGS_PATH)
self.tabs.resize(300, 200)
# Add tabs
self.tabs.addTab(self.mainTab, "Main")
self.tabs.addTab(self.serversTab, "Servers")
self.tabs.currentChanged.connect(self.tab_changed)
self.layout.addWidget(self.tabs)
self.setLayout(self.layout)
def tab_changed(self):
if self.tabs.currentWidget() == self.mainTab:
if self.serversTab.save_settings_change_tab() == "Value Error":
self.tabs.setCurrentIndex(2)
self.mainTab.reload_servers()
def __init__(self, *args, **kwargs):
super(Window, self).__init__(*args, **kwargs)
self.setAttribute(Qt.WA_StyledBackground, True)
setting = QSettings('gradient.ini', QSettings.IniFormat)
setting.setIniCodec('UTF-8')
gradient = setting.value('gradient')
print(gradient)
if gradient:
gradient = GradientUtils.toGradient(gradient)
print(gradient)
gradient = GradientUtils.styleSheetCode(gradient)
print(gradient)
self.setStyleSheet('background: {};'.format(gradient))
gradient = QLinearGradient(0, 0, 1, 1)
gradient.setColorAt(0, Qt.red)
gradient.setColorAt(0.5, Qt.green)
gradient.setColorAt(1, Qt.blue)
gradient = GradientUtils.toJson(gradient)
print(gradient)
setting.setValue('gradient', gradient)
setting.sync()
def loadClueAlbum(self, filename):
# keys with ',' are read as list and will be joined back
if os.path.isfile(filename):
album = QSettings(filename, QSettings.IniFormat)
album.setIniCodec("UTF-8");
for group in album.childGroups():
album.beginGroup(group)
key = group
if not 'fr' in album.childKeys():
self._logger.warning(
"{} [{}] : {}".format(self.tr("Clue"), group, self.tr("ignored because 'fr' is missing")))
continue
if not 'en' in album.childKeys():
self._logger.warning(
"{} [{}] : {}".format(self.tr("Clue"), group, self.tr("ignored because 'en' is missing")))
continue
try:
title = album.value('en')
if '|' in title:
en = re.compile(r'\s*\|\s*').split(title)
else:
en = (title, '')
text = album.value('fr')
if '|' in text:
fr = re.compile(r'\s*\|\s*').split(text)
else:
fr = (text, '')
self._clues[key] = Clue(title, fr, en)
except:
self._logger.warning("{} {}".format(self.tr("Failed to load clue : "), key))
album.endGroup()
class PathConfiForm(QWidget, Ui_PathConfi):
def __init__(self, parent=None):
super(PathConfiForm, self).__init__(parent)
self.setupUi(self)
self.settings = QSettings("userInterface/user_interface.ini",
QSettings.IniFormat)
self.settings.setIniCodec("UTF-8")
self.lineEdit_3.setText(
self.settings.value("SETUP/userInterface/agent_path", 0, type=str))
self.lineEdit_2.setText(
self.settings.value("SETUP/userInterface/carla_path", 1, type=str))
self.agentPath.clicked.connect(self.slot_btn_chooseDir_agentPath)
self.carlaPath.clicked.connect(self.slot_btn_chooseDir_carlaPath)
def slot_btn_chooseDir_agentPath(self):
get_directory_path = QFileDialog.getExistingDirectory(
self, "directory path", "./")
self.lineEdit_3.setText(str(get_directory_path))
self.settings.setValue("SETUP/userInterface/agent_path",
get_directory_path)
def slot_btn_chooseDir_carlaPath(self):
get_carla_path = QFileDialog.getOpenFileName(self, 'carla path', "./")
self.lineEdit_2.setText(str(get_carla_path[0]))
self.settings.setValue("SETUP/userInterface/carla_path",
str(get_carla_path[0]))
class agentSelection(QWidget, Ui_agentSelection):
def __init__(self, parent=None):
super(agentSelection, self).__init__(parent)
self.setupUi(self)
self.settings = QSettings("userInterface/user_interface.ini",
QSettings.IniFormat)
self.settings.setIniCodec("UTF-8")
self.agentfile.clicked.connect(self.openAgentSelection)
self.lineEdit.textChanged.connect(lambda: self.onChanged())
self.lineEdit_2.setText(
self.settings.value("SETUP/userInterface/agent_filename",
3,
type=str))
self.lineEdit.setText(
self.settings.value("SETUP/userInterface/class_name", 14,
type=str))
self.lineEdit_2.setReadOnly(True)
def openAgentSelection(self):
agent_path_name = self.settings.value("SETUP/userInterface/agent_path",
0,
type=str)
openfile_name = QFileDialog.getOpenFileName(self, 'Agent selection',
agent_path_name,
'Python(*.py)')
self.lineEdit_2.setText(str(openfile_name[0]))
self.settings.setValue("SETUP/userInterface/agent_filename",
str(openfile_name[0]))
def onChanged(self):
clas_name = self.lineEdit.text()
self.settings.setValue("SETUP/userInterface/class_name", clas_name)
def get_settings():
"""
return a QSettings instanze
"""
settings = QSettings()
settings.setIniCodec('utf-8')
LOGGER.debug('QSettings format set to: %s', settings.format())
return settings
class childWindow_WT(QDialog):
def __init__(self):
QDialog.__init__(self)
self.child = Ui_WandT()
self.child.setupUi(self)
self.settings = QSettings("userInterface/user_interface.ini",
QSettings.IniFormat)
self.settings.setIniCodec("UTF-8")
self.readWeatherandTimer()
self.child.timeDial.valueChanged.connect(self.changedValue)
self.child.rainfall_capacity.valueChanged.connect(self.changedValue)
self.child.ground_humidity.valueChanged.connect(self.changedValue)
self.child.wind_power.valueChanged.connect(self.changedValue)
self.child.fog.valueChanged.connect(self.changedValue)
self.child.air_humidity.valueChanged.connect(self.changedValue)
self.child.cloundiness.valueChanged.connect(self.changedValue)
def readWeatherandTimer(self):
timedial_record = self.settings.value("SETUP/userInterface/timeDial",
5,
type=str)
self.child.timeDial.setValue(int(timedial_record))
rainfall_capacity_record = self.settings.value(
"SETUP/userInterface/rainfall_capacity", 6, type=str)
self.child.rainfall_capacity.setValue(int(rainfall_capacity_record))
ground_humidity_record = self.settings.value(
"SETUP/userInterface/ground_humidity", 7, type=str)
self.child.ground_humidity.setValue(int(ground_humidity_record))
wind_power_record = self.settings.value(
"SETUP/userInterface/wind_power", 8, type=str)
self.child.wind_power.setValue(int(wind_power_record))
fog_record = self.settings.value("SETUP/userInterface/fog",
9,
type=str)
self.child.fog.setValue(int(fog_record))
air_humidity_record = self.settings.value(
"SETUP/userInterface/air_humidity", 10, type=str)
self.child.air_humidity.setValue(int(air_humidity_record))
cloudiness_record = self.settings.value(
"SETUP/userInterface/cloudiness", 14, type=str)
self.child.cloundiness.setValue(int(cloudiness_record))
def changedValue(self):
self.settings.setValue("SETUP/userInterface/timeDial",
self.child.timeDial.value())
self.settings.setValue("SETUP/userInterface/rainfall_capacity",
self.child.rainfall_capacity.value())
self.settings.setValue("SETUP/userInterface/ground_humidity",
self.child.ground_humidity.value())
self.settings.setValue("SETUP/userInterface/fog",
self.child.fog.value())
self.settings.setValue("SETUP/userInterface/wind_power",
self.child.wind_power.value())
self.settings.setValue("SETUP/userInterface/air_humidity",
self.child.air_humidity.value())
self.settings.setValue("SETUP/userInterface/cloudiness",
self.child.cloundiness.value())
def layoutSaveSettings(self):
settings = QSettings("settings.ini", QSettings.IniFormat)
settings.setIniCodec("UTF-8")
settings.beginGroup("Layout")
settings.setValue("position", self.pos())
settings.setValue("size", self.size())
settings.endGroup()
settings.sync()
def loadLanguage(self):
settings = QSettings("settings.ini", QSettings.IniFormat);
settings.setIniCodec("UTF-8");
settings.beginGroup("Cues")
self._language = settings.value("language", "fr")
settings.endGroup()
if self._selectionComboBox:
self.selectClue(self._selectionComboBox.currentIndex())
def setParameters2(self):
self._logger.info(self.tr("Settings : set French parameters"))
settings = QSettings("settings.ini", QSettings.IniFormat)
settings.setIniCodec("UTF-8")
settings.beginGroup("Parameters")
settings.setValue("param", 'fr')
settings.endGroup()
settings.sync()
def save_to_ini_file(self):
settings = QSettings("ZhongLiuYiYuanConfig.ini", QSettings.IniFormat)
settings.setIniCodec(QTextCodec.codecForName("GB2312"))
settings.beginGroup("CompanyList")
for i in range(len(self.companyList)):
settings.setValue("companyName" + str(i), self.companyList[i])
settings.endGroup()
settings.beginGroup("ItemPriceList")
for j in self.checkItemPriceDict:
settings.setValue(j, str(self.checkItemPriceDict[j]))
settings.endGroup()
def layoutLoadSettings(self):
settings = QSettings("settings.ini", QSettings.IniFormat)
settings.setIniCodec("UTF-8")
settings.beginGroup("Layout")
pos = settings.value("position", QPoint(200, 200))
size = settings.value("size", QSize(400, 400))
settings.endGroup()
self.move(pos)
self.resize(size)
def setCuesInFrench(self):
self._logger.info(self.tr("Settings : set cues in French"))
settings = QSettings("settings.ini", QSettings.IniFormat)
settings.setIniCodec("UTF-8")
settings.beginGroup("Cues")
settings.setValue("language", "fr")
settings.endGroup()
settings.sync()
self.languageChanged.emit()
def create_report(self, dev_type: str, dev_num, date):
settings = QSettings('settings.ini', QSettings.IniFormat)
settings.setIniCodec('UTF-8')
today = datetime.today()
num = self.get_num(settings, today)
path = self.get_path(settings, dev_type, today)
if not path.exists():
path.mkdir(parents=True, exist_ok=True)
self.save_new_report_date(settings, today)
self.save_new_report_num(settings, num)
file = self.get_file_name(dev_type, num, today, dev_num, date)
self.save_pdf(path / file)
self.preview.updatePreview()
def setLanguage(self, lang):
self._logger.info(self.tr("Request received : language in ") + lang)
if lang in ["en", "fr"]:
self._language = lang
settings = QSettings("settings.ini", QSettings.IniFormat);
settings.setIniCodec("UTF-8");
settings.beginGroup("Cues")
settings.setValue("language", self._language)
settings.endGroup()
settings.sync()
if self._selectionComboBox:
self.selectClue(self._selectionComboBox.currentIndex())
class reportDetail_driving(QWidget, Ui_Details_Driving):
def __init__(self, parent=None):
super(reportDetail_driving, self).__init__(parent)
self.setupUi(self)
self.settings = QSettings("userInterface/user_interface.ini",
QSettings.IniFormat)
self.settings.setIniCodec("UTF-8")
def setData(self):
# self.settings = QSettings("userInterface/user_interface.ini", QSettings.IniFormat)
# self.settings.setIniCodec("UTF-8")
record_id = self.settings.value("SETUP/userInterface/cur_page",
13,
type=str)
self.information.setItem(0, 5, QTableWidgetItem(str(5)))
record_list = data_operation.get_detailed_list(int(record_id))
this_record = record_list[0]
self.information.setItem(0, 1, QTableWidgetItem(str(this_record[4])))
self.information.setItem(1, 1, QTableWidgetItem(str(this_record[21])))
is_arrive = ""
if this_record[22] == 1:
is_arrive = "Yes"
else:
is_arrive = "No"
self.information.setItem(2, 1, QTableWidgetItem(is_arrive))
self.information.setItem(3, 1, QTableWidgetItem(str(this_record[23])))
self.information.setItem(4, 1, QTableWidgetItem(str(this_record[5])))
self.information_3.setItem(0, 0, QTableWidgetItem(str(this_record[7])))
self.information_3.setItem(0, 1,
QTableWidgetItem(str(this_record[18])))
self.information_2.setItem(0, 1, QTableWidgetItem(str(this_record[3])))
self.weather.setItem(1, 0, QTableWidgetItem(str(this_record[9])))
self.weather.setItem(1, 1, QTableWidgetItem(str(this_record[10])))
self.weather.setItem(1, 2, QTableWidgetItem(str(int(this_record[11]))))
self.weather.setItem(1, 3, QTableWidgetItem(str(this_record[12])))
self.weather.setItem(1, 4, QTableWidgetItem(str(this_record[13])))
self.weather.setItem(1, 5, QTableWidgetItem(str(this_record[14])))
self.weather.setItem(1, 6, QTableWidgetItem(str(this_record[15])))
self.weather.setItem(1, 7, QTableWidgetItem(str(this_record[16])))
class Settings(object):
qsettings = None
settings_file = None
host = None
port = None
keys_dir = None
public_key = None
public_key_file = None
private_key = None
private_key_file = None
def __init__(self):
pass
def load(self, filename=None):
if filename is None:
self.settings_file = 'settings.ini'
else:
self.settings_file = filename
self.qsettings = QSettings(self.settings_file, QSettings.IniFormat)
self.qsettings.setIniCodec("utf-8")
self.qsettings.beginGroup("Node")
if self.qsettings.value("host") is not None:
self.host = self.qsettings.value("host")
if self.qsettings.value("port") is not None:
self.port = int(self.qsettings.value("port"))
if self.qsettings.value("keys_dir") is not None:
self.keys_dir = self.qsettings.value("keys_dir")
if self.qsettings.value("private_key_file") is not None:
self.private_key_file = self.qsettings.value("private_key_file")
if self.qsettings.value("public_key_file") is not None:
self.public_key_file = self.qsettings.value("public_key_file")
self.qsettings.endGroup()
self.qsettings.sync()
def save(self):
self.qsettings.beginGroup("Node")
self.qsettings.setValue('host', self.host)
self.qsettings.setValue('port', self.port)
self.qsettings.setValue('public_key_file', self.public_key_file)
self.qsettings.setValue('private_key_file', self.private_key_file)
self.qsettings.endGroup()
self.qsettings.sync()
def loadMessages(self):
settings = QSettings("settings.ini", QSettings.IniFormat)
settings.setIniCodec("UTF-8")
settings.beginGroup("Parameters")
lang = settings.value('param', 'en')
settings.endGroup()
predefined_messages = {}
if lang == 'fr':
predefined_messages["Charger un message..."] = None
predefined_messages['Bonjour le Monde'] = 'Bonjour le Monde'
predefined_messages[
'Salut les copains'] = 'Salut les copains!\nComment allez-vous?'
else:
predefined_messages["Load message..."] = None
predefined_messages['Hello World'] = 'Hello World'
predefined_messages[
'Hello folks'] = 'Hello folks!\nHow are you doing?'
self._selectionComboBox.clear()
for key in predefined_messages:
self._selectionComboBox.addItem(key, predefined_messages[key])
def buildUi(self):
main_layout = QVBoxLayout()
main_layout.setSpacing(12)
param_box = QGroupBox(self.tr("Configuration"))
param_box_layout = QVBoxLayout(param_box)
main_layout.addWidget(param_box)
param1_button = QRadioButton(self.tr("Messages in English"))
param2_button = QRadioButton(self.tr("Messages in French"))
param_box_layout.addWidget(param1_button)
param_box_layout.addWidget(param2_button)
settings = QSettings("settings.ini", QSettings.IniFormat)
settings.setIniCodec("UTF-8")
settings.beginGroup("Parameters")
lang = settings.value('param', 'en')
settings.endGroup()
if lang == 'fr':
param2_button.setChecked(True)
else:
param1_button.setChecked(True)
close_button = QPushButton(self.tr("Close"))
close_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
button_layout = QHBoxLayout()
button_layout.addStretch()
button_layout.addWidget(close_button)
main_layout.addLayout(button_layout)
self.setLayout(main_layout)
param1_button.pressed.connect(self.setParameters1)
param2_button.pressed.connect(self.setParameters2)
close_button.pressed.connect(self.accept)
def buildUi(self):
main_layout = QVBoxLayout()
main_layout.setSpacing(12)
lang_box = QGroupBox(self.tr("Clues language"))
lang_box_layout = QVBoxLayout(lang_box)
main_layout.addWidget(lang_box)
eng_button = QRadioButton(self.tr("English"))
fre_button = QRadioButton(self.tr("French"))
lang_box_layout.addWidget(eng_button)
lang_box_layout.addWidget(fre_button)
settings = QSettings("settings.ini", QSettings.IniFormat)
settings.setIniCodec("UTF-8")
settings.beginGroup("Cues")
lang = settings.value("language", "fr")
settings.endGroup()
if lang == "fr":
fre_button.setChecked(True)
else:
eng_button.setChecked(True)
close_button = QPushButton(self.tr("Close"))
close_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
button_layout = QHBoxLayout()
button_layout.addStretch()
button_layout.addWidget(close_button)
main_layout.addLayout(button_layout)
self.setLayout(main_layout)
eng_button.pressed.connect(self.setCuesInEnglish)
fre_button.pressed.connect(self.setCuesInFrench)
close_button.pressed.connect(self.accept)
class parentWindow(QMainWindow, Ui_MainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.main_ui = Ui_MainWindow()
self.main_ui.setupUi(self)
self.settings = QSettings("userInterface/user_interface.ini",
QSettings.IniFormat)
self.settings.setIniCodec("UTF-8")
self.readInit()
# self.main_ui.AgentSelection.clicked.connect(self.openAgentSelection())
def carlaRun(self):
carla_path_name = self.settings.value("SETUP/userInterface/carla_path",
1,
type=str)
# print(carla_path_name)
if carla_path_name == "":
self.warning_message(
"Sorry! Please configure the correct path of CarlaUE4.exe/.sh")
else:
try:
self.slave = Slave()
self.slave.start(carla_path_name)
except Exception as e:
self.warning_message(
"Sorry! Please configure the correct path of CarlaUE4.exe/.sh"
)
def selectionTimer(self):
Timer_currentvalue = self.main_ui.Timer.currentText()
self.settings.setValue("SETUP/userInterface/Timer", Timer_currentvalue)
def readInit(self):
self.settings.setValue("SETUP/userInterface/customize", "false")
Timer_record = self.settings.value("SETUP/userInterface/Timer",
3,
type=str)
Weather_CB_record = self.settings.value(
"SETUP/userInterface/Weather_CB", 4, type=str)
scenario_record = self.settings.value("SETUP/userInterface/scenario",
11,
type=str)
self.main_ui.Timer.setCurrentText(Timer_record)
self.main_ui.Weather_CB.setCurrentText(Weather_CB_record)
self.main_ui.ScenearioSelection.setCurrentText(scenario_record)
self.main_ui.WeatherAndT.setChecked(True)
self.main_ui.label_4.setVisible(True)
self.main_ui.label_5.setVisible(True)
self.main_ui.label_6.setVisible(True)
self.main_ui.label_7.setVisible(True)
self.main_ui.label_8.setVisible(True)
self.main_ui.Timer.setHidden(False)
self.main_ui.Weather_CB.setHidden(False)
self.main_ui.Customize.setHidden(True)
def judgement_WeatherAndT(self):
self.settings.setValue("SETUP/userInterface/customize", "false")
self.main_ui.label_4.setVisible(True)
self.main_ui.label_5.setVisible(True)
self.main_ui.label_6.setVisible(True)
self.main_ui.label_7.setVisible(True)
self.main_ui.label_8.setVisible(True)
self.main_ui.Timer.setHidden(False)
self.main_ui.Weather_CB.setHidden(False)
self.main_ui.Customize.setHidden(True)
def selectionWeather_CB(self):
Weather_CB_currentvalue = self.main_ui.Weather_CB.currentText()
self.settings.setValue("SETUP/userInterface/Weather_CB",
Weather_CB_currentvalue)
def selectionScenario_CB(self):
selectionScenario_CB_currentvalue = self.main_ui.ScenearioSelection.currentText(
)
self.settings.setValue("SETUP/userInterface/scenario",
selectionScenario_CB_currentvalue)
def judgement_CustoizeWAndT(self):
self.settings.setValue("SETUP/userInterface/customize", "true")
def customize_hidden(self):
self.main_ui.label_4.setVisible(False)
self.main_ui.label_5.setVisible(False)
self.main_ui.label_6.setVisible(False)
self.main_ui.label_7.setVisible(False)
self.main_ui.label_8.setVisible(False)
self.main_ui.Timer.setHidden(True)
self.main_ui.Weather_CB.setHidden(True)
self.main_ui.Customize.setHidden(False)
# self.main_ui.Customize.setHidden(customize_record)
def runProgram(self):
# self.slave.start(pyfile path input)
# agent_path_name = self.settings.value("SETUP/userInterface/agent_path", 0, type=str)
# carla_path_name = self.settings.value("SETUP/carla_path", 1, type=str)
customize_record = self.settings.value("SETUP/userInterface/customize",
2,
type=str)
Timer_record = self.settings.value("SETUP/userInterface/Timer",
3,
type=str)
Weather_CB_record = self.settings.value(
"SETUP/userInterface/Weather_CB", 4, type=str)
timedial_record = self.settings.value("SETUP/userInterface/timeDial",
5,
type=str)
rainfall_capacity_record = self.settings.value(
"SETUP/userInterface/rainfall_capacity", 6, type=str)
ground_humidity_record = self.settings.value(
"SETUP/userInterface/ground_humidity", 7, type=str)
wind_power_record = self.settings.value(
"SETUP/userInterface/wind_power", 8, type=str)
fog_record = self.settings.value("SETUP/userInterface/fog",
9,
type=str)
air_humidity_record = self.settings.value(
"SETUP/userInterface/air_humidity", 10, type=str)
cloudiness_record = self.settings.value(
"SETUP/userInterface/cloudiness", 13, type=str)
scenario_record = self.settings.value("SETUP/userInterface/scenario",
11,
type=str)
agent_filename = self.settings.value(
"SETUP/userInterface/agent_filename", 12, type=str)
class_name = self.settings.value("SETUP/userInterface/class_name",
14,
type=str)
message = DictConstruction(
agent_path=agent_filename,
if_custom=customize_record,
preset_time=Timer_record,
preset_weather=Weather_CB_record,
custom_time=timedial_record,
custom_rainfall=rainfall_capacity_record,
custom_ground_humidity=ground_humidity_record,
custom_wind=wind_power_record,
custom_fog=fog_record,
custom_air_humidity=air_humidity_record,
custom_cloud=cloudiness_record,
scenario=scenario_record,
agent_name=class_name)
pass_standard = True
exception_str = ""
if agent_filename == "":
exception_str += " agent file path (Agent Selection);"
pass_standard = False
if class_name == "":
exception_str += " agent class name (Agent Selection);"
pass_standard = False
if pass_standard:
try:
import multiprocessing
err_msg_queue = multiprocessing.Queue()
main_process = multiprocessing.Process(
target=MainLoop.main_loop,
kwargs={
'data_frame': message,
'err_queue': err_msg_queue
})
self.hide()
main_process.start()
# MainLoop.main_loop(message)
QApplication.processEvents() # 刷新界面
time.sleep(0.2)
# main_thread.join()
main_process.join()
self.show()
result = err_msg_queue.get()
if type(result) is dict:
result_report = "Test Done! Your Result is:\n"
result_report += 'Test Scenario: ' + str(
result['Scenario']) + '\n'
result_report += 'Agent Name: ' + str(
result['agent_name']) + '\n'
result_report += 'Mark: ' + str(result['mark']) + '\n'
result_report += "For more details you can see the detail report in the history list\n"
QMessageBox.information(self, "Test Result", result_report)
elif type(result) is str:
self.warning_message(str(result))
except Exception as err:
self.warning_message(str(err))
else:
self.warning_message(
"Sorry! Execution Failed! You should configure" +
exception_str)
def warning_message(self, err_str):
QMessageBox.warning(self, "Execution Error!", err_str)
def closeEvent(self, event):
close = QtWidgets.QMessageBox.question(
self, "QUIT QUERY", "Are you sure to exit the system?",
QtWidgets.QMessageBox.Yes | QtWidgets.QMessageBox.No)
if close == QtWidgets.QMessageBox.Yes:
event.accept()
sys.exit(0)
else:
event.ignore()
class HistoryRecordForm(Ui_historyRecord):
signal_driving0 = pyqtSignal()
signal_driving1 = pyqtSignal()
signal_driving2 = pyqtSignal()
signal_driving3 = pyqtSignal()
signal_driving4 = pyqtSignal()
signal_driving5 = pyqtSignal()
signal_driving6 = pyqtSignal()
signal_driving7 = pyqtSignal()
signal_driving8 = pyqtSignal()
signal_driving9 = pyqtSignal()
signal_detecting0 = pyqtSignal()
signal_detecting1 = pyqtSignal()
signal_detecting2 = pyqtSignal()
signal_detecting3 = pyqtSignal()
signal_detecting4 = pyqtSignal()
signal_detecting5 = pyqtSignal()
signal_detecting6 = pyqtSignal()
signal_detecting7 = pyqtSignal()
signal_detecting8 = pyqtSignal()
signal_detecting9 = pyqtSignal()
def __init__(self, *args, **kwargs):
super(HistoryRecordForm, self).__init__(*args, **kwargs)
self.setupUi()
self.settings = QSettings("userInterface/user_interface.ini",
QSettings.IniFormat)
self.settings.setIniCodec("UTF-8")
def setRecordId(self, colunm):
self.settings.setValue("SETUP/userInterface/cur_page",
str(self.table.item(colunm, 5).text()))
traffic_light_scenario = "Traffic Light"
object_detection = "Object Detection"
# print(self.table.item(colunm, 1).text())
if colunm == 0:
if self.table.item(
colunm,
1).text() == traffic_light_scenario or self.table.item(
colunm, 1).text() == object_detection:
self.signal_detecting0.emit()
else:
self.signal_driving0.emit()
if colunm == 1:
if self.table.item(
colunm,
1).text() == traffic_light_scenario or self.table.item(
colunm, 1).text() == object_detection:
self.signal_detecting1.emit()
else:
self.signal_driving1.emit()
if colunm == 2:
if self.table.item(
colunm,
1).text() == traffic_light_scenario or self.table.item(
colunm, 1).text() == object_detection:
self.signal_detecting2.emit()
else:
self.signal_driving2.emit()
if colunm == 3:
if self.table.item(
colunm,
1).text() == traffic_light_scenario or self.table.item(
colunm, 1).text() == object_detection:
self.signal_detecting3.emit()
else:
self.signal_driving3.emit()
if colunm == 4:
if self.table.item(
colunm,
1).text() == traffic_light_scenario or self.table.item(
colunm, 1).text() == object_detection:
self.signal_detecting4.emit()
else:
self.signal_driving4.emit()
if colunm == 5:
if self.table.item(
colunm,
1).text() == traffic_light_scenario or self.table.item(
colunm, 1).text() == object_detection:
self.signal_detecting5.emit()
else:
self.signal_driving5.emit()
if colunm == 6:
if self.table.item(
colunm,
1).text() == traffic_light_scenario or self.table.item(
colunm, 1).text() == object_detection:
self.signal_detecting6.emit()
else:
self.signal_driving6.emit()
if colunm == 7:
if self.table.item(
colunm,
1).text() == traffic_light_scenario or self.table.item(
colunm, 1).text() == object_detection:
self.signal_detecting7.emit()
else:
self.signal_driving7.emit()
if colunm == 8:
if self.table.item(
colunm,
1).text() == traffic_light_scenario or self.table.item(
colunm, 1).text() == object_detection:
self.signal_detecting8.emit()
else:
self.signal_driving8.emit()
if colunm == 9:
if self.table.item(
colunm,
1).text() == traffic_light_scenario or self.table.item(
colunm, 1).text() == object_detection:
self.signal_detecting9.emit()
else:
self.signal_driving9.emit()
'''
class ConnectionPanel(QWidget):
def __init__(self, parent=None, settings=None):
QWidget.__init__(self, parent)
self.main_layout = QVBoxLayout()
self.setLayout(self.main_layout)
# settings
self.ini = QSettings(settings, QSettings.IniFormat)
self.ini.setIniCodec("utf-8")
self.last_login = ""
self.ALIAS_DICT = {}
self.VPN_SERVERS = {}
self.load_settings()
vpn_layout_1 = QHBoxLayout()
vpn_layout_2 = QHBoxLayout()
self.line_login = QLineEdit()
if self.last_login != "":
self.line_login.setText(self.last_login)
else:
self.line_login.setPlaceholderText("Login")
self.line_login.setStyleSheet("""
QLineEdit {
border: 0.5px solid grey;
border-radius: 2px;
background: #f3f3f3;
}
QLineEdit:focus {
border: 0.5px solid grey;
border-radius: 2px;
background:white;
}""")
self.line_password = QLineEdit()
self.line_password.setEchoMode(QLineEdit.Password)
self.line_password.setPlaceholderText("Password")
self.line_password.setStyleSheet("""
QLineEdit {
border: 0.5px solid grey;
border-radius: 2px;
background: #f3f3f3;
}
QLineEdit:focus {
border: 0.5px solid grey;
border-radius: 2px;
background:white;
}""")
self.line_password.returnPressed.connect(self.enable_vpn)
vpn_layout_1.addWidget(self.line_login)
vpn_layout_1.addWidget(self.line_password)
checkbox_layout = QHBoxLayout()
self.checkbox = QCheckBox("Remember login")
self.checkbox.setChecked(True)
checkbox_layout.addWidget(self.checkbox)
self.vpn_button = Button("Enable VPN", self.enable_vpn)
# check that vpn is not started
proc = []
for p in psutil.process_iter(attrs=['name']):
proc.append(p.info['name'])
if "dsSamProxy.exe" in proc:
self.vpn_button.setDisabled(True)
else:
self.vpn_button.setDisabled(False)
self.vpn_servers = QComboBox()
self.vpn_servers.addItems(self.VPN_SERVERS.values())
vpn_layout_2.addWidget(self.vpn_servers)
vpn_layout_2.addWidget(self.vpn_button)
# RDP conection line
servers_layout = QHBoxLayout()
self.servers_box = QComboBox()
self.servers_box.addItems(self.ALIAS_DICT.keys())
self.servers_box.currentIndexChanged.connect(self.server_property)
self.servers_connect = Button("RDP connection", self.get_RDP_conn)
servers_layout.addWidget(self.servers_box)
servers_layout.addWidget(self.servers_connect)
# Information group
self.group_box = QGroupBox()
self.group_box_layout = QVBoxLayout()
self.label = QLabel(
f"Server adress: {self.ALIAS_DICT[self.servers_box.currentText()]}"
)
self.group_box.setLayout(self.group_box_layout)
self.group_box_layout.addWidget(self.label)
self.group_box.setTitle("Server information")
self.main_layout.addLayout(vpn_layout_1)
self.main_layout.addLayout(checkbox_layout)
self.main_layout.addLayout(vpn_layout_2)
self.main_layout.addSpacing(10)
self.main_layout.addLayout(servers_layout)
self.main_layout.addWidget(self.group_box)
self.main_layout.addStretch(2)
self.show()
def load_settings(self):
"""
load settings
:return:
"""
self.ini.beginGroup("Login")
self.last_login = self.ini.value("last_login")
self.ini.endGroup()
self.ini.beginGroup("Servers")
for key in self.ini.childKeys():
self.ALIAS_DICT.update({key: self.ini.value(key)})
self.ini.endGroup()
self.ini.beginGroup('Extended_VPN')
for key in self.ini.childKeys():
self.VPN_SERVERS.update({key: self.ini.value(key)})
self.ini.endGroup()
def enable_vpn(self):
"""
Activate VPN
:return:
"""
login = self.line_login.text()
password = self.line_password.text()
if self.checkbox.isChecked():
self.ini.setValue("last_login", login)
else:
self.settings.setValue("last_login", "")
response = startVPN(login, password, self.vpn_servers.currentText())
if response:
self.vpn_button.setDisabled(True)
else:
print("ERRROOOOORRRR!!!!!!")
def reload_servers(self):
"""
Update Combobox with servers names when you back from "Servers" tab
:return:
"""
old_keys = [
self.servers_box.itemText(i)
for i in range(0, self.servers_box.count())
]
self.ini.beginGroup("Servers")
self.ALIAS_DICT = {}
for key in self.ini.childKeys():
self.ALIAS_DICT.update({key: self.ini.value(key)})
for key in self.ALIAS_DICT.keys():
if key not in old_keys:
self.servers_box.addItem(key)
for key in old_keys:
if key not in self.ini.childKeys():
self.servers_box.removeItem(self.servers_box.findText(key))
self.ini.endGroup()
def get_RDP_conn(self):
"""
connect by RDP
:return:
"""
Popen(
f"C:\Windows\System32\mstsc.exe /v {self.ALIAS_DICT[self.servers_box.currentText()]}",
shell=True)
def server_property(self):
"""
Just show servers property
:return:
"""
self.label.setText(
f"Server adress: {self.ALIAS_DICT[self.servers_box.currentText()]}"
)
class ServersTable(QWidget):
def __init__(self, parent=None, settings= None):
QWidget.__init__(self, parent)
self.table_layout = QVBoxLayout()
self.setLayout(self.table_layout)
self.temp_cell = ""
self.ini = QSettings(settings, QSettings.IniFormat)
self.ini.setIniCodec("utf-8")
self.servers_table = QTableWidget()
self.servers_table.setColumnCount(2)
self.servers_table.setHorizontalHeaderLabels(["Server Alias", "Server Name"])
self.servers_table.setSortingEnabled(True)
self.load_settings()
self.table_layout.addWidget(self.servers_table)
self.button_add = Button("Add", self.add_row)
self.button_save = Button("Save", self.save_settings_change_tab)
self.button_delete = Button("Delete", self.del_row)
butt_layout = QHBoxLayout()
butt_layout.addStretch(1)
butt_layout.addWidget(self.button_add)
butt_layout.addWidget(self.button_delete)
butt_layout.addWidget(self.button_save)
self.table_layout.addLayout(butt_layout)
self.show()
def clicked_cell(self):
"""
Get cell text from current cell
:return:
"""
x = self.servers_table.currentRow()
y = self.servers_table.currentColumn()
self.temp_cell = self.servers_table.item(x, y).text()
def load_settings(self):
"""
load settings from file
:return:
"""
self.ini.beginGroup("Servers")
temp_dict = {}
for key in self.ini.childKeys():
temp_dict.update({key: self.ini.value(key)})
self.ini.endGroup()
i = 0
while temp_dict:
if not i:
self.servers_table.setRowCount(1)
else:
self.servers_table.setRowCount(i+1)
item = temp_dict.popitem()
self.servers_table.setItem(i, 0, QTableWidgetItem(item[0]))
self.servers_table.setItem(i, 1, QTableWidgetItem(item[1]))
i += 1
self.servers_table.resizeColumnsToContents()
def save_changes(self):
"""
Save changes, which done in table without changing rows count
:return:
"""
x = self.servers_table.currentRow()
y = self.servers_table.currentColumn()
if self.temp_cell != self.servers_table.item(x, y).text():
self.ini.beginGroup("Servers")
if y == 0:
self.ini.remove(self.temp_cell)
self.ini.setValue(self.servers_table.item(x, y).text(), self.servers_table.item(x, y+1).text())
elif y == 1:
self.ini.setValue(self.servers_table.item(x, y-1).text(), self.servers_table.item(x, y).text())
self.ini.endGroup()
def add_row(self):
"""
Add new row to the table
:return:
"""
curr_count = self.servers_table.rowCount()
self.servers_table.insertRow(curr_count)
def del_row(self):
"""
delete selected row
:return:
"""
self.servers_table.removeRow(self.servers_table.currentRow())
print("Row was deleted!")
def save_settings_change_tab(self):
"""
Save changes, when tab has changed
:return:
"""
all_rows = self.servers_table.rowCount()
self.ini.beginGroup("Servers")
total_rows = len(self.ini.childKeys())
total_keys = self.ini.childKeys()
self.ini.endGroup()
if all_rows:
curr_keys = []
self.ini.beginGroup("Servers")
for i in range(0, all_rows):
try:
key = self.servers_table.item(i, 0).text()
curr_keys.append(key)
value = self.servers_table.item(i, 1).text()
self.ini.setValue(key, value)
except Exception:
# todo Add message for this error + paint cells red
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Error!")
msg.setWindowTitle("Value Error!")
msg.setInformativeText(f"You try to save None value in row {i}")
x = msg.exec_()
# remove deleted lines from settings
for key in total_keys:
if key not in curr_keys:
self.ini.remove(key)
self.ini.endGroup()
self.ini.sync()
class Config(QObject):
"Configuration provider for the whole program, wapper for QSettings"
row_height_changed = pyqtSignal(int)
def __init__(self, log=None):
super().__init__()
if log:
self.log = log.getChild('Conf')
self.log.setLevel(30)
else:
self.log = logging.getLogger()
self.log.setLevel(99)
self.log.debug('Initializing')
self.qsettings = QSettings()
self.qsettings.setIniCodec('UTF-8')
self.options = None
self.option_spec = self.load_option_spec()
self.options = self.load_options()
self.full_name = "{} {}".format(QCoreApplication.applicationName(),
QCoreApplication.applicationVersion())
# options that need fast access are also definded as attributes, which
# are updated by calling update_attributes()
# (on paper it's 4 times faster, but i don't think it matters in my case)
self.logger_table_font = None
self.logger_table_font_size = None
self.loop_event_delay = None
self.benchmark_interval = None
self.update_attributes()
def __getitem__(self, name):
# self.log.debug('Getting "{}"'.format(name))
value = self.options.get(name, None)
if value is None:
raise Exception('No option with name "{}"'.format(name))
# self.log.debug('Returning "{}"'.format(value))
return value
def __setitem__(self, name, value):
# self.log.debug('Setting "{}"'.format(name))
if name not in self.options:
raise Exception('No option with name "{}"'.format(name))
self.options[name] = value
def set_option(self, name, value):
self[name] = value
@staticmethod
def get_resource_path(name, directory='ui'):
data_dir = resource_filename('cutelog', directory)
path = os.path.join(data_dir, name)
if not os.path.exists(path):
raise FileNotFoundError(
'Resource file not found in this path: "{}"'.format(path))
return path
def get_ui_qfile(self, name):
file = QFile(':/ui/{}'.format(name))
if not file.exists():
raise FileNotFoundError(
'ui file not found: ":/ui/{}"'.format(name))
file.open(QFile.ReadOnly)
return file
@property
def listen_address(self):
host = self.options.get('listen_host', None)
port = self.options.get('listen_port', None)
if host is None or port is None:
raise Exception(
'Listen host or port not in options: "{}:{}"'.format(
host, port))
return (host, port)
def load_option_spec(self):
option_spec = []
for spec in OPTION_SPEC:
option = Option(*spec)
option_spec.append(option)
return option_spec
def load_options(self):
self.log.debug('Loading options')
options = {}
self.qsettings.beginGroup('Configuration')
for option in self.option_spec:
value = self.qsettings.value(option.name, option.default)
if option.type == bool:
value = str(value).lower(
) # needed because QSettings stores bools as strings
value = True if value == "true" or value is True else False
else:
value = option.type(value)
options[option.name] = value
self.qsettings.endGroup()
return options
def update_options(self, new_options, save=True):
self.options.update(new_options)
if save:
self.save_options()
self.update_attributes(new_options)
def update_attributes(self, options=None):
"Updates fast attributes and everything else outside of self.options"
if options:
# here will be things that only need to be updated when they actually changed
new_row_height = options.get('logger_row_height',
self.options['logger_row_height'])
if new_row_height != self.options['logger_row_height']:
self.row_height_changed.emit(new_row_height)
else:
options = self.options
self.loop_event_delay = options.get('loop_event_delay',
self.loop_event_delay)
self.benchmark_interval = options.get('benchmark_interval',
self.benchmark_interval)
self.logger_table_font = options.get('logger_table_font',
self.logger_table_font)
self.logger_table_font_size = options.get('logger_table_font_size',
self.logger_table_font_size)
self.set_logging_level(
options.get('console_logging_level', ROOT_LOG.level))
def save_options(self):
self.log.debug('Saving options')
self.qsettings.beginGroup('Configuration')
for option in self.option_spec:
self.qsettings.setValue(option.name, self.options[option.name])
self.qsettings.endGroup()
self.sync()
def sync(self):
self.log.debug('Syncing QSettings')
self.qsettings.sync()
def set_settings_value(self, name, value):
self.qsettings.beginGroup('Configuration')
self.qsettings.setValue(name, value)
self.qsettings.endGroup()
def set_logging_level(self, level):
global ROOT_LOG
ROOT_LOG.setLevel(level)
self.log.setLevel(level)
# def save_levels_preset(self, levels, preset_name):
# pass
def get_header_presets(self):
self.qsettings.beginGroup('Header_Presets')
result = self.qsettings.childGroups()
self.qsettings.endGroup()
return result
def save_header_preset(self, name, columns):
self.log.debug('Saving header preset "{}"'.format(name))
s = self.qsettings
s.beginGroup('Header_Presets')
s.beginWriteArray(name, len(columns))
for i, col in enumerate(columns):
s.setArrayIndex(i)
s.setValue('column', col.dump_to_string())
s.endArray()
s.endGroup()
def load_header_preset(self, name):
from .logger_table_header import Column
self.log.debug('Loading header preset "{}"'.format(name))
s = self.qsettings
result = []
if name not in self.get_header_presets():
return None
s.beginGroup('Header_Presets')
size = s.beginReadArray(name)
for i in range(size):
s.setArrayIndex(i)
new_column = Column(load=s.value('column'))
result.append(new_column)
s.endArray()
s.endGroup()
return result
def save_geometry(self, geometry):
s = self.qsettings
s.beginGroup('Geometry')
s.setValue('Main_Window_Geometry', geometry)
s.endGroup()
self.sync()
def load_geometry(self):
s = self.qsettings
s.beginGroup('Geometry')
geometry = s.value('Main_Window_Geometry')
s.endGroup()
return geometry
def get_QSettings():
settings = QSettings()
settings.setIniCodec('utf-8')
logger.debug('QSettings format set to: %s' % settings.format())
return settings
def __init__(self, argv, client, debugging_mqtt=False):
super().__init__(argv)
self.setApplicationName(APPNAME)
settings = QSettings("settings.ini", QSettings.IniFormat)
settings.setIniCodec("UTF-8")
settings.beginGroup("MQTT")
self.publishMessageRequest.connect(self.publishMessage)
self._definitions = {}
self._mqttSubscriptions = []
if os.path.isfile('definitions.ini'):
definitions = QSettings('definitions.ini', QSettings.IniFormat)
for group in definitions.childGroups():
definitions.beginGroup(group)
if group == "mqtt":
for key in definitions.childKeys():
self._definitions[key] = definitions.value(key)
if key.startswith('mqtt-sub-'):
self._mqttSubscriptions.append(
self._definitions[key])
definitions.endGroup()
self._mqttClient = client
self._mqttConnected = False
self._mqttServerHost = settings.value('host', MQTT_DEFAULT_HOST)
self._mqttServerPort = settings.value('port',
MQTT_DEFAULT_PORT,
type=int)
self._mqttClient.on_connect = self.mqttOnConnect
self._mqttClient.on_disconnect = self.mqttOnDisconnect
self._mqttClient.on_message = self.mqttOnMessage
self._mqttClient.on_publish = self.mqttOnPublish
self._mqttClient.on_subscribe = self.mqttOnSubscribe
self._mqttClient.on_unsubscribe = self.mqttOnUnsubscribe
if debugging_mqtt:
self._mqttClient.on_log = self.mqttOnLog
parser = argparse.ArgumentParser()
parser.add_argument("-s",
"--server",
help="change MQTT server host",
nargs=1)
parser.add_argument("-p",
"--port",
help="change MQTT server port",
nargs=1,
type=int)
parser.add_argument("-d",
"--debug",
help="set DEBUG log level",
action='store_true')
parser.add_argument("-l",
"--logger",
help="use logging config file",
nargs=1)
try:
args = vars(parser.parse_args())
if args['server']:
self._mqttServerHost = args['server'][0]
settings.setValue('host', self._mqttServerHost)
if args['port']:
self._mqttServerPort = args['port'][0]
settings.setValue('port', self._mqttServerPort)
if args['logger'] and os.path.isfile(args['logger']):
logging.config.fileConfig(args['logger'])
if args['debug']:
self._logger = logging.getLogger('debug')
self._logger.setLevel(logging.DEBUG)
else:
self._logger = logging.getLogger('production')
self._logger.setLevel(logging.INFO)
elif os.path.isfile('logging.ini'):
logging.config.fileConfig('logging.ini')
if args['debug']:
self._logger = logging.getLogger('debug')
self._logger.setLevel(logging.DEBUG)
else:
self._logger = logging.getLogger('production')
self._logger.setLevel(logging.INFO)
else:
if args['debug']:
self._logger = logging.getLogger('debug')
self._logger.setLevel(logging.DEBUG)
else:
self._logger = logging.getLogger('production')
self._logger.setLevel(logging.INFO)
ch = logging.FileHandler('plugin.log', 'w')
ch.setLevel(logging.INFO)
self._logger.addHandler(ch)
except:
pass
class reportDetail_detecting(QWidget, Ui_detailReport_detect):
def __init__(self, parent=None):
super(reportDetail_detecting, self).__init__(parent)
self.setupUi(self)
def setData(self):
self.settings = QSettings("userInterface/user_interface.ini",
QSettings.IniFormat)
self.settings.setIniCodec("UTF-8")
cur_page = self.settings.value("SETUP/userInterface/cur_page",
13,
type=str)
record_list = data_operation.get_detailed_list(int(cur_page))
this_record = record_list[0]
self.weather.setItem(1, 0, QTableWidgetItem(str(this_record[9])))
self.weather.setItem(1, 1, QTableWidgetItem(str(this_record[10])))
self.weather.setItem(1, 2, QTableWidgetItem(str(int(this_record[11]))))
self.weather.setItem(1, 3, QTableWidgetItem(str(this_record[12])))
self.weather.setItem(1, 4, QTableWidgetItem(str(this_record[13])))
self.weather.setItem(1, 5, QTableWidgetItem(str(this_record[14])))
self.weather.setItem(1, 6, QTableWidgetItem(str(this_record[15])))
self.weather.setItem(1, 7, QTableWidgetItem(str(this_record[16])))
# set test time
self.information_3.setItem(0, 0, QTableWidgetItem(str(this_record[7])))
# set scenario name
self.information_3.setItem(0, 1,
QTableWidgetItem(str(this_record[18])))
#set mark
self.information_2.setItem(0, 1, QTableWidgetItem(str(this_record[3])))
# agent information
self.information.setItem(0, 1, QTableWidgetItem(str(this_record[4])))
self.information.setItem(3, 1, QTableWidgetItem(str(this_record[5])))
# accuracy
self.information.setItem(1, 1,
QTableWidgetItem(str(this_record[21]) + '%'))
# avg time
self.information.setItem(2, 1,
QTableWidgetItem(str(this_record[22]) + 's'))
# detects and answer setting
detects_str = str(this_record[23])
answer_str = str(this_record[24])
detects_arr = detects_str.split(sep="|")
answer_arr = answer_str.split(sep="|")
attr_length = len(detects_arr)
self.details.setColumnCount(attr_length + 1)
for i in range(0, attr_length + 1):
self.details.setItem(0, i, QtWidgets.QTableWidgetItem())
_translate = QtCore.QCoreApplication.translate
item = self.details.item(0, 0)
item.setText(_translate("Form", "Detects"))
item = self.details.item(1, 0)
item.setText(_translate("Form", "Answers"))
for i in range(0, attr_length):
item = self.details.item(0, i + 1)
item.setText(_translate("Form", detects_arr[i]))
item = self.details.item(1, i + 1)
item.setText(_translate("Form", answer_arr[i]))
def get_report_num_and_date(self) -> Tuple[int, str]:
settings = QSettings('settings.ini', QSettings.IniFormat)
settings.setIniCodec('UTF-8')
date = settings.value('protocol/date', '01.01.2019')
num = settings.value('protocol/num', 0, int)
return num, date
