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