def _clearSettings(self): """ Just clears all peacock settings. """ settings = QSettings() settings.clear() settings.sync()
def window(tmpdir_factory): api_key = hexlify(os.urandom(16)) root_state_dir = str(tmpdir_factory.mktemp('tribler_state_dir')) app = TriblerApplication("triblerapp-guitest", sys.argv) # We must create a separate instance of QSettings and clear it. # Otherwise, previous runs of the same app will affect this run. settings = QSettings("tribler-guitest") settings.clear() window = TriblerWindow( # pylint: disable=W0621 settings, root_state_dir, api_key=api_key, core_args=[ str(RUN_TRIBLER_PY.absolute()), '--core', '--gui-test-mode' ], ) # pylint: disable=W0621 app.set_activation_window(window) QTest.qWaitForWindowExposed(window) screenshot(window, name="tribler_loading") wait_for_signal( window.core_manager.events_manager.tribler_started, flag=window.core_manager.events_manager.tribler_started_flag, ) window.downloads_page.can_update_items = True yield window window.close_tribler() screenshot(window, name="tribler_closing") QApplication.quit()
def __init__(self, imgDir, start_args): # Create the userdir if it doesn't exist if not os.path.exists(user_dir): os.makedirs(user_dir) # Initialize Logs initLogs() super().__init__() # Register the signal handlers signal.signal(signal.SIGTERM, service_shutdown) signal.signal(signal.SIGINT, service_shutdown) # Get version and title self.version = getVersion() self.title = 'PET4L - PIVX Emergency Tool For Ledger - v.%s-%s' % ( self.version['number'], self.version['tag']) # Open database self.db = Database(self) self.db.open() # Check for startup args (clear data) if start_args.clearAppData: settings = QSettings('PIVX', 'PET4L') settings.clear() # Clear DB self.db.clearTable('UTXOS') # Read cached app data self.cache = readCacheSettings() # Initialize user interface self.initUI(imgDir)
def BorrarConf(clave=None, sistema=None): if not sistema: sistema = Constantes.SISTEMA settings = QSettings(Constantes.EMPRESA, sistema) if clave: settings.remove(clave) else: settings.clear()
def setUp(self): QCoreApplication.setOrganizationName("msam") QCoreApplication.setOrganizationDomain("dummy_domain.com") QCoreApplication.setApplicationName('test_versa3d') settings = QSettings() settings.clear() self.singleton = Versa3dSettings() self.singleton.load_all()
def setUp(self): super(Tests, self).setUp() settings = QSettings() settings.clear() self.main_win = QtWidgets.QMainWindow() self.menubar = self.main_win.menuBar() self.test_menu = self.menubar.addMenu("Test recently used") self.ru_menu = RecentlyUsedMenu(self.test_menu, "test/recentlyUsed", "test/maxRecentlyUsed", 20) self.ru_menu.selected.connect(self.selected) self.name_selected = None
def make_app(): global app, settings app = QApplication(sys.argv) app.setOrganizationName("PGDP") app.setOrganizationDomain("pgdp.net") app.setApplicationName("PPQT2") settings = QSettings() settings.clear() settings.setValue("paths/dicts_path",path_to_Files) settings.setValue("dictionaries/default_tag","en_US") settings.setValue("mainwindow/position",QPoint(50,50))
def make_app(): global app, settings app = QApplication(sys.argv) app.setOrganizationName("PGDP") app.setOrganizationDomain("pgdp.net") app.setApplicationName("PPQT2") settings = QSettings() settings.clear() settings.setValue("paths/dicts_path", path_to_Files) settings.setValue("dictionaries/default_tag", "en_US") settings.setValue("mainwindow/position", QPoint(50, 50))
class TestCreateDirsControl(TestCase): def __init__(self, *args, **kwargs): super(TestCreateDirsControl, self).__init__(*args, **kwargs) self.regkey = 'zero_substance/test' ddiirr = os.path.dirname(__file__) os.chdir(os.path.realpath(ddiirr + '/../')) def setUp(self): self.settings = QSettings(self.regkey, 'structjour') realSettings = QSettings('zero_substance', 'structjour') # This setting required in createDirs self.settings.setValue('scheme', realSettings.value('scheme')) self.settings.setValue('directories_autogen', 'true') cwd = os.getcwd() self.test_jdir = os.path.join(cwd, 'test/journal_test') self.settings.setValue('journal', self.test_jdir) self.w = CreateDirs(testSettings=self.settings) self.w.debug = True def tearDown(self): # pass self.settings.clear() self.settings.sync() if os.path.exists(self.test_jdir): rmtree(self.test_jdir) # self.settings.remove(self.regkey) def test_enableAutoGen(self): QTest.mouseClick(self.w.ui.disabledRb, Qt.LeftButton) QTest.mouseClick(self.w.ui.enabledRb, Qt.LeftButton) self.assertEqual(self.settings.value('directories_autogen'), 'true') def test_disableAutoGen(self): QTest.mouseClick(self.w.ui.enabledRb, Qt.LeftButton) QTest.mouseClick(self.w.ui.disabledRb, Qt.LeftButton) self.assertEqual(self.settings.value('directories_autogen'), 'false') def testCreateDirs(self): if not os.path.exists(self.test_jdir): os.makedirs(self.test_jdir) cb_year = self.w.ui.createDirsYear cb_month = self.w.ui.createDirsMonth cb_year.setCurrentIndex(cb_year.count() - 1) cb_month.setCurrentIndex(cb_month.count() - 1) # m = pd.Timestamp(f'{cb_year.currentText()} {cb_month.currentText()}') theDir = self.w.createDirs() self.assertTrue(os.path.exists(theDir)) def test_CreateDirs_fail(self): self.settings.setValue('journal', "") theDir = self.w.createDirs() self.assertEqual(theDir, "") self.settings.setValue('journal', self.test_jdir)
def __init__(self, imgDir, app, start_args): # Create the userdir if it doesn't exist if not os.path.exists(user_dir): os.makedirs(user_dir) # Initialize Logs initLogs() super().__init__() self.app = app # Register the signal handlers signal.signal(signal.SIGTERM, service_shutdown) signal.signal(signal.SIGINT, service_shutdown) # Get version and title self.version = getSPMTVersion() self.title = 'SPMT - Secure PIVX Masternode Tool - v.%s-%s' % ( self.version['number'], self.version['tag']) # Open database self.db = Database(self) self.db.open() # Clean v4 migration (read data from old files and delete them) clean_v4_migration(self) # Check for startup args (clear data) if start_args.clearAppData: settings = QSettings('PIVX', 'SecurePivxMasternodeTool') settings.clear() if start_args.clearRpcData: self.db.clearTable('CUSTOM_RPC_SERVERS') if start_args.clearMnData: self.db.clearTable('MASTERNODES') if start_args.clearTxCache: self.db.clearTable('RAWTXES') # Clear Rewards and Governance DB (in case of forced shutdown) self.db.clearTable('REWARDS') self.db.clearTable('PROPOSALS') self.db.clearTable('MY_VOTES') # Remove raw txes updated earlier than two months ago (if not already cleared) if not start_args.clearTxCache: self.db.clearRawTxes(time() - SECONDS_IN_2_MONTHS) # Read Masternode List masternode_list = self.db.getMasternodeList() # Read cached app data self.cache = readCacheSettings() # Initialize user interface self.initUI(masternode_list, imgDir)
def resetPushButtonPressed(self, button): # create an object for PersepolisDB persepolis_db = PersepolisDB() # Reset data base persepolis_db.resetDataBase() # close connections persepolis_db.closeConnections() # Reset persepolis_setting persepolis_setting = QSettings('persepolis_download_manager', 'persepolis') persepolis_setting.clear() persepolis_setting.sync()
class Settings(): def __init__(self, companyName, applicationName): self.__settings = QSettings(companyName, applicationName) def clear(self): self.__settings.clear() # API def get_selected_language(self): return self.__settings.value("Simply-Paint-Settings/selected_language") def set_selected_language(self, lang): self.__settings.setValue("Simply-Paint-Settings/selected_language", lang)
def handleClickedButtonSave(self): setting = QSettings() setting.clear() text = self.ui.textEdit.toPlainText() lines = text.split() setting.beginGroup("domains") for line in lines: line = line.strip() line = line.replace('http://', '').replace('https://', '') line = (line.split('/'))[0] if line: setting.setValue(line, "") setting.endGroup() setting.sync() self.close()
def moveSettingsToNewRoot(): """Move all settings to one application file.""" movelist = [[appinfo.name, appinfo.url, False], "metainfo", "snippets", "sessions", "sessiondata"] for moveitem in movelist: if isinstance(moveitem, string_types): moveitem = [moveitem, appinfo.name, True] o = QSettings(moveitem[1], moveitem[0]) o.setFallbacksEnabled(False) keys = o.allKeys() if len(keys) > 0: s = QSettings() if moveitem[2]: s.beginGroup(moveitem[0]) for k in keys: s.setValue(k, o.value(k)) o.clear()
def __init__(self, imgDir, app, start_args): # Create the userdir if it doesn't exist if not os.path.exists(user_dir): os.makedirs(user_dir) # Initialize Logs initLogs() super().__init__() self.app = app # Register the signal handlers signal.signal(signal.SIGTERM, service_shutdown) signal.signal(signal.SIGINT, service_shutdown) # Get version and title self.version = getVersion() self.title = 'PET4L - PIVX Emergency Tool For Ledger - v.%s-%s' % (self.version['number'], self.version['tag']) # Open database self.db = Database(self) self.db.openDB() # Check for startup args (clear data) if start_args.clearAppData: settings = QSettings('PIVX', 'PET4L') settings.clear() if start_args.clearTxCache: self.db.clearTable('RAWTXES') # Clear DB self.db.clearTable('UTXOS') # Remove raw txes updated earlier than two months ago (if not already cleared) if not start_args.clearTxCache: self.db.clearRawTxes(time() - SECONDS_IN_2_MONTHS) # Read cached app data self.cache = readCacheSettings() # Initialize user interface self.initUI(imgDir)
class FMIConfig: def __init__(self): self.config = QSettings('FMI.ini', QSettings.IniFormat) pass def saveNtripValue(self, group, key, value): self.config.beginGroup(group) self.config.setValue(key, value) self.config.endGroup() pass def getValue(self, group, key): self.config.beginGroup(group) value = self.config.value(key, "") self.config.endGroup() return value def getGroupKeys(self, group): try: self.config.beginGroup(group) keys = self.config.childKeys() self.config.endGroup() return keys except Exception as e: print(e) return None def clear(self): self.config.clear() pass def close(self): pass def getCmdComb(self, CMD): if "VEH_MODE" in CMD: return VEH_MODE elif "UAV_MODE" in CMD: return UAV_MODE return CMD
os.chdir(files_path) ppqt_path = '/Users/dcortes1/Dropbox/David/PPQT/V2/ppqt' sys.path.append(ppqt_path) # Create an app and empty settings from PyQt5.QtWidgets import QApplication app = QApplication(sys.argv) import constants as C app.setOrganizationName("PGDP") app.setOrganizationDomain("pgdp.net") app.setApplicationName("PPQT2") from PyQt5.QtCore import QSettings settings = QSettings() import mainwindow from PyQt5.QtCore import Qt, QPoint, QSize settings.clear() settings.setValue("mainwindow/position", QPoint(0, 0)) mw = mainwindow.MainWindow(settings) mw.show() app.exec_() # idle a bit after quit to let garbage be collected from PyQt5.QtTest import QTest QTest.qWait(200) #app.quit() #mw = None #mwp = mw.pos() #mws = mw.size()
class Settings(dict): """ Easier way to manage different parameters. Briefly speaking it combines conventional dictionary with the additional interface to QSettings via 'persistentStorage' property """ def __init__(self, defaults: str = '../defaultSettings.json'): """ Settings constructor. Automatically retrieving settings from the persistent storage if they are present :param defaults: path to default settings JSON file """ super(Settings, self).__init__() with open(defaults, mode='r') as defaultSettingsJSONFile: self.defaults = json.load(defaultSettingsJSONFile) self.persistentStorage = QSettings() self._retrieve() def _retrieve(self) -> None: """ Determines whether settings are present in the system storage and based on that decides what to choose :return: None """ # It seems like QT or OS stores additional parameters unwanted for us (at least on macOS) so we isolate our # storage using 'app' group self.persistentStorage.beginGroup('app') if not self.persistentStorage.contains('settings'): print("No settings, clear all, use default...") self.persistentStorage.endGroup() self.persistentStorage.clear() # update() is the inherited method of the dictionary to update its items. We assume that 'defaults' will not # change but for a confidence we make a copy self.update(copy.deepcopy(self.defaults)) # self.save(self.defaults) else: print("Restore from NV-storage") self.update(self.persistentStorage.value('settings', type=dict)) self.persistentStorage.endGroup() def save(self, settings: dict) -> None: """ Push settings from the given dictionary to the persistent storage :param settings: dictionary containing settings. Any subclass including this can be passed as well :return: None """ print("Saving settings...") self.persistentStorage.beginGroup('app') self.persistentStorage.setValue('settings', copy.deepcopy(settings)) self.persistentStorage.endGroup() def __deepcopy__(self, memodict={}) -> dict: """ As this class contains additional properties such as QSettings that we don't want to be copied we need to override __deepcopy__ method :param memodict: see deepcopy docs, not used in our case :return: copied dictionary """ # inner instruction makes temporary shallow copy of the dictionary (without custom options) and outer is # performing an actual deep-copying return copy.deepcopy(dict(self))
class Ui_OptionsForm(QWidget): def __init__(self): super().__init__() def setupUi(self, OptionsForm): self.settings = QSettings('JayInc', 'Entertainment Planner') self.movie = { "Title": "The Shawshank Redemption", "Year": "1994", "Rated": "R", "Released": "14 Oct 1994", "Runtime": "142 min", "Genre": "Drama", "Director": "Frank Darabont", "Writer": "Stephen King (short story \"Rita Hayworth and Shawshank Redemption\"),Frank Darabont (screenplay)", "Actors": "Tim Robbins, Morgan Freeman, Bob Gunton, William Sadler", "Plot": "Two imprisoned men bond over a number of years, finding solace and eventual redemption through acts of common decency.", "Language": "English", "Country": "USA", "Awards": "Nominated for 7 Oscars. Another 21 wins & 36 nominations.", "Poster": "https://m.media-amazon.com/images/M/MV5BMDFkYTc0MGEtZmNhMC00ZDIzLWFmNTEtODM1ZmRlYWMwMWFmXkEyXkFqcGdeQXVyMTMxODk2OTU@._V1_SX300.jpg", "Ratings": [{ "Source": "Internet Movie Database", "Value": "9.3/10" }, { "Source": "Rotten Tomatoes", "Value": "91%" }, { "Source": "Metacritic", "Value": "80/100" }], "Metascore": "80", "imdbRating": "9.3", "imdbVotes": "2,367,380", "imdbID": "tt0111161", "Type": "movie", "DVD": "15 Aug 2008", "BoxOffice": "$28,699,976", "Production": "Columbia Pictures, Castle Rock Entertainment", "Website": "N/A" } self.options_form = OptionsForm OptionsForm.setObjectName("OptionsForm") OptionsForm.resize(580, 491) OptionsForm.setMinimumSize(QtCore.QSize(580, 491)) OptionsForm.setMaximumSize(QtCore.QSize(580, 491)) self.label = QtWidgets.QLabel(OptionsForm) self.label.setGeometry(QtCore.QRect(10, 10, 61, 21)) font = QtGui.QFont() font.setPointSize(10) self.label.setFont(font) self.label.setTextFormat(QtCore.Qt.AutoText) self.label.setObjectName("label") self.apiLineEdit = QtWidgets.QLineEdit(OptionsForm) self.apiLineEdit.setGeometry(QtCore.QRect(70, 10, 61, 21)) self.apiLineEdit.setInputMask("") self.apiLineEdit.setObjectName("apiLineEdit") self.validateApiButton = QtWidgets.QPushButton(OptionsForm) self.validateApiButton.setGeometry(QtCore.QRect(140, 10, 81, 23)) self.validateApiButton.setObjectName("validateApiButton") self.validateApiLabel = QtWidgets.QLabel(OptionsForm) self.validateApiLabel.setGeometry(QtCore.QRect(230, 10, 101, 21)) font = QtGui.QFont() font.setPointSize(10) self.validateApiLabel.setFont(font) self.validateApiLabel.setTextFormat(QtCore.Qt.AutoText) self.validateApiLabel.setObjectName("validateApiLabel") self.line = QtWidgets.QFrame(OptionsForm) self.line.setGeometry(QtCore.QRect(6, 440, 571, 21)) self.line.setFrameShape(QtWidgets.QFrame.HLine) self.line.setFrameShadow(QtWidgets.QFrame.Sunken) self.line.setObjectName("line") self.saveButton = QtWidgets.QPushButton(OptionsForm) self.saveButton.setGeometry(QtCore.QRect(290, 460, 281, 23)) self.saveButton.setObjectName("saveButton") self.autoSaveCheckBox = QtWidgets.QCheckBox(OptionsForm) self.autoSaveCheckBox.setGeometry(QtCore.QRect(10, 50, 371, 17)) font = QtGui.QFont() font.setPointSize(10) self.autoSaveCheckBox.setFont(font) self.autoSaveCheckBox.setObjectName("autoSaveCheckBox") self.autoCloseCheckBox = QtWidgets.QCheckBox(OptionsForm) self.autoCloseCheckBox.setGeometry(QtCore.QRect(10, 90, 301, 17)) font = QtGui.QFont() font.setPointSize(10) self.autoCloseCheckBox.setFont(font) self.autoCloseCheckBox.setObjectName("autoCloseCheckBox") self.customMovieFormatCheckBox = QtWidgets.QCheckBox(OptionsForm) self.customMovieFormatCheckBox.setGeometry( QtCore.QRect(10, 130, 451, 17)) font = QtGui.QFont() font.setPointSize(10) self.customMovieFormatCheckBox.setFont(font) self.customMovieFormatCheckBox.setObjectName( "customMovieFormatCheckBox") self.customFormatPlainTextEdit = QtWidgets.QPlainTextEdit(OptionsForm) self.customFormatPlainTextEdit.setGeometry( QtCore.QRect(10, 160, 561, 131)) self.customFormatPlainTextEdit.setObjectName( "customFormatPlainTextEdit") self.checkJsonListButton = QtWidgets.QPushButton(OptionsForm) self.checkJsonListButton.setGeometry(QtCore.QRect(490, 130, 81, 21)) self.checkJsonListButton.setObjectName("checkJsonListButton") self.customFormatResultsPlainTextEdit = QtWidgets.QPlainTextEdit( OptionsForm) self.customFormatResultsPlainTextEdit.setGeometry( QtCore.QRect(10, 300, 561, 141)) self.customFormatResultsPlainTextEdit.setPlainText("") self.customFormatResultsPlainTextEdit.setObjectName( "customFormatResultsPlainTextEdit") self.clearOptionsButton = QtWidgets.QPushButton(OptionsForm) self.clearOptionsButton.setGeometry(QtCore.QRect(10, 460, 271, 23)) self.clearOptionsButton.setObjectName("clearOptionsButton") self.retranslateUi(OptionsForm) QtCore.QMetaObject.connectSlotsByName(OptionsForm) self.connect_buttons_manually() self.load_options() def retranslateUi(self, OptionsForm): _translate = QtCore.QCoreApplication.translate OptionsForm.setWindowTitle(_translate("OptionsForm", "Options")) self.apiLineEdit.setText(_translate("OptionsForm", "")) self.label.setText(_translate("OptionsForm", "OmdbApi:")) self.validateApiButton.setText( _translate("OptionsForm", "Validate API")) self.saveButton.setText(_translate("OptionsForm", "Save")) self.autoSaveCheckBox.setText( _translate( "OptionsForm", "Auto save movie to file when \"Save Movie To List\" is clicked." )) self.autoSaveCheckBox.setChecked(False) self.autoCloseCheckBox.setText( _translate("OptionsForm", "Auto close movie window when movie is saved.")) self.autoCloseCheckBox.setChecked(False) self.customMovieFormatCheckBox.setText( _translate("OptionsForm", "Use custom format for movie save.")) self.customMovieFormatCheckBox.setChecked(False) self.customFormatPlainTextEdit.setPlainText( _translate( "OptionsForm", "For Example:\n" "\n" "\'[ {Title} | ⌚ {Runtime} | ⭐ {Genre} | 📅 {Released} | {Rated} ]\n" "\n" "OR\n" "\n" " (IMDB): {imdbID}\n" " Name: {Title}\n" " Duration: {Runtime} ⌚\n" "Release Date: {Released} 📅\n" " Rated: {Rated}\n" "\n" "OR\n" "\n" "The movies name is {Title} and it runs for {Runtime} long. The rating is amazing at {imdbRating} stars in IMDB." )) self.checkJsonListButton.setText(_translate("OptionsForm", "JSON Keys")) self.clearOptionsButton.setText( _translate("OptionsForm", "Clear Options")) def connect_buttons_manually(self): self.validateApiButton.clicked.connect(self.validate_api_button_click) self.saveButton.clicked.connect(self.save_options) self.checkJsonListButton.clicked.connect(self.available_json_list) self.clearOptionsButton.clicked.connect(self.clear_options) self.customFormatPlainTextEdit.textChanged.connect( self.show_format_text) self.customMovieFormatCheckBox.stateChanged.connect( self.custom_movie_format_checkbox) def validate_api_button_click(self): api_Key = self.apiLineEdit.text().strip() request_url = 'https://www.omdbapi.com/?apikey=' + api_Key result = requests.get(request_url).json() if (result['Error'] == 'Incorrect IMDb ID.'): self.validateApiLabel.setText( '<font color="green">Valid API key!</font>') if (result['Error'] == 'Invalid API key!'): self.validateApiLabel.setText( '<font color="red">Invalid API key!</font>') def custom_movie_format_checkbox(self): if (self.customMovieFormatCheckBox.isChecked()): self.checkJsonListButton.setEnabled(True) self.customFormatPlainTextEdit.setEnabled(True) self.customFormatResultsPlainTextEdit.setEnabled(True) else: self.checkJsonListButton.setEnabled(False) self.customFormatPlainTextEdit.setEnabled(False) self.customFormatResultsPlainTextEdit.setEnabled(False) def available_json_list(self): self.json_format_window = QtWidgets.QWidget() self.json_format_window_ui = Ui_JsonFormatForm() self.json_format_window_ui.setupUi(self.json_format_window) self.json_format_window.show() def show_format_text(self): custom_format_text = self.customFormatPlainTextEdit.toPlainText() tokens = re.split(r'\{(.*?)\}', custom_format_text) keywords = tokens[1::2] try: values = {k: self.movie.get(k, '') for k in keywords} self.customFormatResultsPlainTextEdit.setPlainText( custom_format_text.format(**values)) except (ValueError): pass def load_options(self): if (self.settings.value('api_key')): self.apiLineEdit.setText(self.settings.value('api_key')) if (self.settings.value('auto_save_check_box')): self.autoSaveCheckBox.setChecked( self.value_to_bool(self.settings.value('auto_save_check_box'))) if (self.settings.value('auto_close_check_box')): self.autoCloseCheckBox.setChecked( self.value_to_bool( self.settings.value('auto_close_check_box'))) if (self.settings.value('custom_format_check_box')): self.customMovieFormatCheckBox.setChecked( self.value_to_bool( self.settings.value('custom_format_check_box'))) if (self.settings.value('custom_format_text')): self.customFormatPlainTextEdit.setPlainText( self.settings.value('custom_format_text')) def save_options(self): self.settings.setValue('api_key', self.apiLineEdit.text().strip()) self.settings.setValue('auto_save_check_box', self.autoSaveCheckBox.isChecked()) self.settings.setValue('auto_close_check_box', self.autoCloseCheckBox.isChecked()) self.settings.setValue('custom_format_check_box', self.customMovieFormatCheckBox.isChecked()) self.settings.setValue('custom_format_text', self.customFormatPlainTextEdit.toPlainText()) message_box = QMessageBox() message_box.setWindowTitle('Save Options') message_box.setText('Options has been saved.') message_box.setIcon(QMessageBox.Information) message_box.setStandardButtons(QMessageBox.Ok) message_box.exec_() def clear_options(self): self.settings.clear() self.retranslateUi(self.options_form) def value_to_bool(self, value): return value.lower() == 'true' if isinstance(value, str) else bool(value)
def resetSettings(self): settings = QSettings() settings.clear() self.readSettings()
def tearDown(self): settings = QSettings() settings.clear()
# persepolis --clear >> remove config_folder if args.clear: from persepolis.scripts.data_base import PersepolisDB # create an object for PersepolisDB persepolis_db = PersepolisDB() # Reset data base persepolis_db.resetDataBase() # close connections persepolis_db.closeConnections() # Reset persepolis_setting persepolis_setting = QSettings('persepolis_download_manager', 'persepolis') persepolis_setting.clear() persepolis_setting.sync() sys.exit(0) # persepolis --default >> remove persepolis setting. if args.default: persepolis_setting = QSettings('persepolis_download_manager', 'persepolis') persepolis_setting.clear() persepolis_setting.sync() print ('Persepolis restored default') sys.exit(0) if args.link : add_link_dictionary ['link'] = "".join(args.link)
class PickleSettings: '''A utility to store and restore settings for use in testing. Be careful not to lose data.''' def __init__(self): ddiirr = os.path.dirname(__file__) os.chdir(os.path.realpath(ddiirr)) self.settings = QSettings('zero_substance', 'structjour') self.apisettings = QSettings('zero_substance/stockapi', 'structjour') self.chartsettings = QSettings('zero_substance/chart', 'structjour') self.setkeys = [] self.setvals = [] self.apisetkeys = [] self.apisetvals = [] self.name = os.path.join(ddiirr, 'pickleset.zst') # print(self.name) def setUp(self): ddiirr = os.path.dirname(__file__) os.chdir(os.path.realpath(ddiirr + '/../')) def tearDown(self): self.setUp() def initializeSettings(self): self.settings.clear() self.apisettings.clear() self.chartsettings.clear() def removePickle(self): if os.path.exists(self.name): os.remove(self.name) def initializeVars(self): self.setkeys = [] self.setvals = [] self.apisetkeys = [] self.apisetvals = [] self.chartkeys = [] self.chartvals = [] def storeSettings(self, replacePickle=False): if os.path.exists(self.name): if not replacePickle: return self.initializeVars() self.setkeys = self.settings.allKeys() for k in self.setkeys: self.setvals.append(self.settings.value(k)) self.apisetkeys = self.apisettings.allKeys() for k in self.apisetkeys: self.apisetvals.append(self.apisettings.value(k)) self.chartkeys = self.chartsettings.allKeys() for k in self.chartkeys: self.chartvals.append(self.chartsettings.value(k)) setsnkeys = [ self.setkeys, self.setvals, self.apisetkeys, self.apisetvals, self.chartkeys, self.chartvals ] with open(self.name, "wb") as f: '''Cannot pickle qsettings objects- so we pickle a list''' pickle.dump((setsnkeys), f) def restoreSettings(self): if os.path.exists(self.name): with open(self.name, "rb") as f: setsnkeys = pickle.load(f) for k, v in zip(setsnkeys[0], setsnkeys[1]): self.settings.setValue(k, v) for k2, v2 in zip(setsnkeys[2], setsnkeys[3]): self.apisettings.setValue(k2, v2) for k2, v2 in zip(setsnkeys[4], setsnkeys[5]): self.chartsettings.setValue(k2, v2) os.remove(self.name) else: print(f'No pickle found at {self.name}')
class AddVoiceFilesWidget(QWidget): def __init__(self): super().__init__() self.init_ui() def init_ui(self): self.layout = QVBoxLayout() self.settings = QSettings("voice_file_settings", "GP_IVR_Settings") self.error = False self.browse_button_group = QButtonGroup(self) self.setup_heading() self.voiceflow_settings = QSettings("simplified_voiceflow", "GP_IVR_Settings") self.voice_files = {} self.node_ids = [] self.setup_voice_files_form() self.init_settings() self.setup_buttons() self.setLayout(self.layout) def setup_heading(self): heading_font = QFont('Arial', 12) heading_font.setBold(True) rules_font = QFont('Arial', 10) rules_font.setItalic(True) self.layout.addWidget(QLabel()) heading = QLabel("Add Recorded Voice Files to IVR:") heading.setFont(heading_font) page_info = QLabel( "You can add personal recorded voice files in place of the automatically\n generated voice files for each " "question in the IVR.") file_type_rule = QLabel("* WAV Files Only") file_type_rule.setFont(rules_font) self.layout.addWidget(heading) self.layout.addWidget(page_info) self.layout.addWidget(file_type_rule) def setup_buttons(self): button_layout = QHBoxLayout() back_button_creator = BackButton() self.back_button = back_button_creator.create_back_button() button_layout.addWidget(self.back_button) self.apply_settings_button = QPushButton("Apply") self.apply_settings_button.setToolTip( "Replace IVR voice files with updated files") button_layout.addWidget(self.apply_settings_button) self.layout.addWidget(QLabel()) self.layout.addLayout(button_layout) def init_settings(self): for node in self.voice_files: node_value = self.settings.value(node) if node_value: self.voice_files[node].setText(node_value) def setup_voice_files_form(self): voiceflow_settings = GetVoiceflowSettings( self.voiceflow_settings.value("simplified json")) ivr_texts = voiceflow_settings.get_ivr_texts() if ivr_texts == -1: msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText("Error\n\nYou have not set up an IVR") msg.setWindowTitle("Error") msg.exec_() return for node in ivr_texts: self.add_voice_file_input(ivr_texts[node], node) def add_voice_file_input(self, ivr_text, ivr_node): ivr_text = QLabel(ivr_text) ivr_text.setWordWrap(True) voice_file = WavFileEdit(self) self.button_group = QGroupBox() self.layout.addWidget(self.button_group) self.v_box = QHBoxLayout() self.button_group.setLayout(self.v_box) browse_files_button = QPushButton("Browse", self) browse_files_button.setToolTip("Browse file manager for WAV file") self.v_box.addWidget(ivr_text) grow_label = QLabel() self.v_box.addWidget(grow_label) grow_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding) self.v_box.addWidget(voice_file) self.v_box.addWidget(browse_files_button) self.voice_files[ivr_node] = voice_file self.browse_button_group.addButton(browse_files_button) self.node_ids.append(ivr_node) def get_files(self, voice_file_edit): filepath = QFileDialog.getOpenFileName(self, 'Single File', "~", '*.wav') voice_file_edit.setText(filepath[0]) def apply_settings(self): self.save_settings() voice_file_paths = [] node_ids = [] for node in self.voice_files: voice_file_path_text = self.voice_files[node].text() voice_file_path = Path(voice_file_path_text) if not voice_file_path.is_file(): if not voice_file_path_text: continue msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText("Error\n\nThe Path Specified is not a File") msg.setWindowTitle("Error") msg.exec_() self.error = True return node_ids.append(node) voice_file_paths.append(self.voice_files[node].text()) if voice_file_paths: modify_voice_files = ModifyVoiceFiles( asterisk_constants.VOICE_FILE_PATH, node_ids, voice_file_paths) modify_voice_files.replace_asterisk_voice_files() def save_settings(self): self.settings.clear() for node in self.voice_files: if self.voice_files[node].text(): self.settings.setValue(node, self.voice_files[node].text()) def browse_files(self, button): voice_file_index = -2 - self.browse_button_group.id(button) self.get_files(self.voice_files[self.node_ids[voice_file_index]])
log_stdo = logging.StreamHandler() log_stdo.setLevel(logging.DEBUG) log_stdo.setFormatter(logging.Formatter('[%(levelname)s][%(funcName)s]: %(message)s')) log.addHandler(log_stdo) QCoreApplication.setApplicationName(APP_NAME) QCoreApplication.setApplicationVersion(APP_VERSION) QCoreApplication.setOrganizationName(APP_ORG) ap = argparse.ArgumentParser(description=APP_NAME) ap.add_argument('--reset', action='store_true', dest='reset', help='Reset user preferences and start.') ap.add_argument(nargs='?', type=str, dest='path', default=None, help='Path of a file or directory to open on startup.') args = ap.parse_args() reset = args.reset path = args.path qa = QApplication(sys.argv) s = None if reset: s = QSettings(QSettings.UserScope, APP_ORG, APP_NAME) s.clear() main_window = GalleryMark(log, qa, path=path, settings=s) sys.exit(qa.exec_())
def resetSettings(self): resetSettings = QSettings(QSettings.UserScope, "astrastudio", "OnAirScreen") resetSettings.clear() self.sigConfigFinished.emit() self.close()
class TestSettingsHandler(TestCase): def setUp(self): self.settings = QSettings("KhaleelKhan", "SettingsApp-unittest") self.settings.clear() self.form = SettingsHandler(settings=self.settings) self.form.show() def tearDown(self): self.form.close() del self.form def test_defaults(self): self.assertEqual(self.form.le_latex_tempate.text(), os.path.abspath('Latex/Templates/Awesome-CV/Latex_template.tex')) self.assertEqual(self.form.le_text_template.text(), os.path.abspath('Text/Templates/Simple/Text_template.txt')) self.assertEqual(self.form.le_latex_out_dir.text(), os.path.abspath('Latex/Output')) self.assertEqual(self.form.le_text_out_dir.text(), os.path.abspath('Text/Output')) self.assertTrue(self.form.cb_open_pdf_after.isChecked()) self.assertTrue(self.form.cb_open_text_after.isChecked()) self.assertTrue(self.form.cb_keep_tex.isChecked()) self.assertEqual(self.form.combo_latex_compiler.currentText(), 'xelatex') self.assertEqual(self.form.le_custom_latex.text(), '') self.assertFalse(self.form.le_custom_latex.isEnabled()) self.assertTrue(self.form.latex_buttonBox.button(QtWidgets.QDialogButtonBox.Ok).isEnabled()) self.assertTrue(self.form.latex_buttonBox.button(QtWidgets.QDialogButtonBox.Apply).isEnabled()) self.assertTrue(self.form.text_buttonBox.button(QtWidgets.QDialogButtonBox.Ok).isEnabled()) self.assertTrue(self.form.text_buttonBox.button(QtWidgets.QDialogButtonBox.Apply).isEnabled()) def test_latex_compiler_changed(self): # reset value of combo box self.form.combo_latex_compiler.setCurrentText('xelatex') self.form.combo_latex_compiler.setCurrentText('custom') self.assertTrue(self.form.le_custom_latex.isEnabled()) self.form.combo_latex_compiler.setCurrentText('xelatex') self.assertFalse(self.form.le_custom_latex.isEnabled()) self.form.combo_latex_compiler.setCurrentText('pdflatex') self.assertFalse(self.form.le_custom_latex.isEnabled()) def test_write_settings_to_config(self): # Write dummy values to variables self.form.latex_template = "latex_template_test_write_settings" self.form.text_template = "text_template_test_write_settings" self.form.latex_dir = "latex_out_dir_test_write_settings" self.form.text_dir = "text_out_dir_test_write_settings" self.form.open_pdf = True self.form.open_text = True self.form.keep_tex = True self.form.latex_compiler = "xelatex" self.form.latex_custom_command = "custom_command_test_write_settings" self.form.write_settings_to_config() # Read from config to verify self.settings.beginGroup("Templates") self.assertEqual(self.settings.value("latex"), "latex_template_test_write_settings") self.assertEqual(self.settings.value("text"), "text_template_test_write_settings") self.settings.endGroup() self.settings.beginGroup("Outputs") self.assertEqual(self.settings.value("latex"), "latex_out_dir_test_write_settings") self.assertEqual(self.settings.value("text"), "text_out_dir_test_write_settings") self.settings.endGroup() self.settings.beginGroup("Misc") self.assertEqual(self.settings.value("open_pdf"), 'True') self.assertEqual(self.settings.value("open_text"), 'True') self.assertEqual(self.settings.value("keep_tex"), 'True') self.assertEqual(self.settings.value("latex_compiler"), "xelatex") self.assertEqual(self.settings.value("latex_custom_command"), "custom_command_test_write_settings") self.settings.endGroup() # Test for False self.form.open_pdf = False self.form.open_text = False self.form.keep_tex = False self.form.write_settings_to_config() self.settings.beginGroup("Misc") self.assertEqual(self.settings.value("open_pdf"), 'False') self.assertEqual(self.settings.value("open_text"), 'False') self.assertEqual(self.settings.value("keep_tex"), 'False') self.settings.endGroup() def test_read_settings_from_config(self): # Write dummy settings to config self.settings.beginGroup("Templates") self.settings.setValue("latex", "latex_template_test_read_settings") self.settings.setValue("text", "text_template_test_read_settings") self.settings.endGroup() self.settings.beginGroup("Outputs") self.settings.setValue("latex", "latex_dir_test_read_settings") self.settings.setValue("text", "text_dir_test_read_settings") self.settings.endGroup() self.settings.beginGroup("Misc") self.settings.setValue("open_pdf", "True") self.settings.setValue("open_text", "True") self.settings.setValue("keep_tex", "True") self.settings.setValue("latex_compiler", "xelatex") self.settings.setValue("latex_custom_command", "custom_command_test_read_settings") self.settings.endGroup() # Save to config self.settings.sync() self.form.read_settings_from_config() self.assertEqual(self.form.latex_template, "latex_template_test_read_settings") self.assertEqual(self.form.text_template, "text_template_test_read_settings") self.assertEqual(self.form.latex_dir, "latex_dir_test_read_settings") self.assertEqual(self.form.text_dir, "text_dir_test_read_settings") self.assertTrue(self.form.open_pdf) self.assertTrue(self.form.open_text) self.assertTrue(self.form.keep_tex) self.assertEqual(self.form.latex_compiler, 'xelatex') self.assertEqual(self.form.latex_custom_command, "custom_command_test_read_settings") # Test for False self.settings.beginGroup("Misc") self.settings.setValue("open_pdf", "False") self.settings.setValue("open_text", "False") self.settings.setValue("keep_tex", "False") self.settings.setValue("latex_compiler", "custom") self.settings.setValue("latex_custom_command", "custom_command_test_read_settings") self.settings.endGroup() # Save to config self.settings.sync() self.form.read_settings_from_config() self.assertFalse(self.form.open_pdf) self.assertFalse(self.form.open_text) self.assertFalse(self.form.keep_tex) self.assertEqual(self.form.latex_compiler, 'custom') self.assertEqual(self.form.latex_custom_command, "custom_command_test_read_settings") def test_get_latex_compiler(self): self.form.latex_compiler = 'custom' self.form.latex_custom_command = "test string" self.assertEqual(self.form.get_latex_compiler(), "test string") self.form.latex_compiler = 'xelatex' self.assertEqual(self.form.get_latex_compiler(), "xelatex") self.form.latex_compiler = 'pdflatex' self.assertEqual(self.form.get_latex_compiler(), "pdflatex") def test_invalid_combobox_setting(self): self.form.combo_latex_compiler.setCurrentText('xelatex') self.assertEqual(self.form.combo_latex_compiler.currentText(), 'xelatex') self.form.combo_latex_compiler.setCurrentText('invalid') # Should still be same self.assertEqual(self.form.combo_latex_compiler.currentText(), 'xelatex') def test_click_okay_button(self): self.reset_all_variables() self.reset_all_ui_elements() # Set ui elements self.form.le_latex_tempate.setText(os.path.abspath('Latex/Templates/Awesome-CV/Latex_template.tex')) self.form.le_text_template.setText(os.path.abspath('Text/Templates/Simple/Text_template.txt')) self.form.le_latex_out_dir.setText(os.path.abspath('Latex/Output')) self.form.le_text_out_dir.setText(os.path.abspath('Text/Output')) self.form.cb_open_pdf_after.setChecked(True) self.form.cb_open_text_after.setChecked(True) self.form.cb_keep_tex.setChecked(True) self.form.combo_latex_compiler.setCurrentText('custom') self.form.le_custom_latex.setText("test string") # Emulate click on OK button button = self.form.latex_buttonBox.button(self.form.latex_buttonBox.Ok) QTest.mouseClick(button, QtCore.Qt.LeftButton) self.assertEqual(self.form.latex_template, os.path.abspath('Latex/Templates/Awesome-CV/Latex_template.tex')) self.assertEqual(self.form.text_template, os.path.abspath('Text/Templates/Simple/Text_template.txt')) self.assertEqual(self.form.latex_dir, os.path.abspath('Latex/Output')) self.assertEqual(self.form.text_dir, os.path.abspath('Text/Output')) self.assertTrue(self.form.open_pdf) self.assertTrue(self.form.open_text) self.assertTrue(self.form.keep_tex) self.assertEqual(self.form.latex_compiler, 'custom') self.assertEqual(self.form.latex_custom_command, "test string") # Test for False self.form.cb_open_pdf_after.setChecked(False) self.form.cb_open_text_after.setChecked(False) self.form.cb_keep_tex.setChecked(False) self.form.combo_latex_compiler.setCurrentText('xelatex') # Emulate click on OK button button = self.form.latex_buttonBox.button(self.form.latex_buttonBox.Ok) QTest.mouseClick(button, QtCore.Qt.LeftButton) self.assertFalse(self.form.open_pdf) self.assertFalse(self.form.open_text) self.assertFalse(self.form.keep_tex) self.assertEqual(self.form.latex_compiler, 'xelatex') def test_click_apply_button(self): self.reset_all_variables() self.reset_all_ui_elements() # Set ui elements self.form.le_latex_tempate.setText(os.path.abspath('Latex/Templates/Awesome-CV/Latex_template.tex')) self.form.le_text_template.setText(os.path.abspath('Text/Templates/Simple/Text_template.txt')) self.form.le_latex_out_dir.setText(os.path.abspath('Latex/Output')) self.form.le_text_out_dir.setText(os.path.abspath('Text/Output')) self.form.cb_open_pdf_after.setChecked(True) self.form.cb_open_text_after.setChecked(True) self.form.cb_keep_tex.setChecked(True) self.form.combo_latex_compiler.setCurrentText('custom') self.form.le_custom_latex.setText("test string") # Emulate click on Apply button button = self.form.latex_buttonBox.button(self.form.latex_buttonBox.Apply) QTest.mouseClick(button, QtCore.Qt.LeftButton) self.assertEqual(self.form.latex_template, os.path.abspath('Latex/Templates/Awesome-CV/Latex_template.tex')) self.assertEqual(self.form.text_template, os.path.abspath('Text/Templates/Simple/Text_template.txt')) self.assertEqual(self.form.latex_dir, os.path.abspath('Latex/Output')) self.assertEqual(self.form.text_dir, os.path.abspath('Text/Output')) self.assertTrue(self.form.open_pdf) self.assertTrue(self.form.open_text) self.assertTrue(self.form.keep_tex) self.assertEqual(self.form.latex_compiler, 'custom') self.assertEqual(self.form.latex_custom_command, "test string") # Test for False self.form.cb_open_pdf_after.setChecked(False) self.form.cb_open_text_after.setChecked(False) self.form.cb_keep_tex.setChecked(False) self.form.combo_latex_compiler.setCurrentText('xelatex') # Emulate click on Apply button button = self.form.latex_buttonBox.button(self.form.latex_buttonBox.Apply) QTest.mouseClick(button, QtCore.Qt.LeftButton) self.assertFalse(self.form.open_pdf) self.assertFalse(self.form.open_text) self.assertFalse(self.form.keep_tex) self.assertEqual(self.form.latex_compiler, 'xelatex') def test_click_cancel_button(self): self.reset_all_ui_elements() # Emulate click on Cancel button button = self.form.latex_buttonBox.button(self.form.latex_buttonBox.Cancel) QTest.mouseClick(button, QtCore.Qt.LeftButton) # Test if everything is still default self.assertEqual(self.form.le_latex_tempate.text(), os.path.abspath('Latex/Templates/Awesome-CV/Latex_template.tex')) self.assertEqual(self.form.le_text_template.text(), os.path.abspath('Text/Templates/Simple/Text_template.txt')) self.assertEqual(self.form.le_latex_out_dir.text(), os.path.abspath('Latex/Output')) self.assertEqual(self.form.le_text_out_dir.text(), os.path.abspath('Text/Output')) self.assertTrue(self.form.cb_open_pdf_after.isChecked()) self.assertTrue(self.form.cb_open_text_after.isChecked()) self.assertTrue(self.form.cb_keep_tex.isChecked()) self.assertEqual(self.form.combo_latex_compiler.currentText(), 'xelatex') self.assertEqual(self.form.le_custom_latex.text(), '') # Test for False self.form.cb_open_pdf_after.setChecked(False) self.form.cb_open_text_after.setChecked(False) self.form.cb_keep_tex.setChecked(False) self.form.combo_latex_compiler.setCurrentText('xelatex') # Emulate click on Cancel button button = self.form.latex_buttonBox.button(self.form.latex_buttonBox.Cancel) QTest.mouseClick(button, QtCore.Qt.LeftButton) # still nothing should be changed self.assertTrue(self.form.cb_open_pdf_after.isChecked()) self.assertTrue(self.form.cb_open_text_after.isChecked()) self.assertTrue(self.form.cb_keep_tex.isChecked()) self.assertEqual(self.form.combo_latex_compiler.currentText(), 'xelatex') self.assertEqual(self.form.le_custom_latex.text(), '') def test_setting_window_closed(self): self.reset_all_ui_elements() # Emulate click on close button self.form.close() # Test if everything is still default self.assertEqual(self.form.le_latex_tempate.text(), os.path.abspath('Latex/Templates/Awesome-CV/Latex_template.tex')) self.assertEqual(self.form.le_text_template.text(), os.path.abspath('Text/Templates/Simple/Text_template.txt')) self.assertEqual(self.form.le_latex_out_dir.text(), os.path.abspath('Latex/Output')) self.assertEqual(self.form.le_text_out_dir.text(), os.path.abspath('Text/Output')) self.assertTrue(self.form.cb_open_pdf_after.isChecked()) self.assertTrue(self.form.cb_open_text_after.isChecked()) self.assertTrue(self.form.cb_keep_tex.isChecked()) self.assertEqual(self.form.combo_latex_compiler.currentText(), 'xelatex') self.assertEqual(self.form.le_custom_latex.text(), '') # Test for False self.form.cb_open_pdf_after.setChecked(False) self.form.cb_open_text_after.setChecked(False) self.form.cb_keep_tex.setChecked(False) self.form.combo_latex_compiler.setCurrentText('xelatex') # Emulate click on close button self.form.close() # still nothing should be changed self.assertTrue(self.form.cb_open_pdf_after.isChecked()) self.assertTrue(self.form.cb_open_text_after.isChecked()) self.assertTrue(self.form.cb_keep_tex.isChecked()) self.assertEqual(self.form.combo_latex_compiler.currentText(), 'xelatex') self.assertEqual(self.form.le_custom_latex.text(), '') @mock.patch('CoverletterCreator.SettingsHandler.os.path') def test_verify_path_field(self, mock_path): mock_path.exists.return_value = True self.form.verify_path_field('test_path_true', self.form.icon_latex_template) mock_path.exists.assert_called_with('test_path_true') self.assertTrue(self.form.latex_buttonBox.button(QtWidgets.QDialogButtonBox.Ok).isEnabled()) self.assertTrue(self.form.text_buttonBox.button(QtWidgets.QDialogButtonBox.Ok).isEnabled()) self.assertTrue(self.form.latex_buttonBox.button(QtWidgets.QDialogButtonBox.Apply).isEnabled()) self.assertTrue(self.form.text_buttonBox.button(QtWidgets.QDialogButtonBox.Apply).isEnabled()) mock_path.exists.return_value = False self.form.verify_path_field('test_path_false', self.form.icon_latex_template) mock_path.exists.assert_called_with('test_path_false') self.assertFalse(self.form.latex_buttonBox.button(QtWidgets.QDialogButtonBox.Ok).isEnabled()) self.assertFalse(self.form.text_buttonBox.button(QtWidgets.QDialogButtonBox.Ok).isEnabled()) self.assertFalse(self.form.latex_buttonBox.button(QtWidgets.QDialogButtonBox.Apply).isEnabled()) self.assertFalse(self.form.text_buttonBox.button(QtWidgets.QDialogButtonBox.Apply).isEnabled()) @mock.patch('CoverletterCreator.SettingsHandler.QFileDialog', autospec=True) def test_open_latex_template(self, mock_opendialog): mock_opendialog.getOpenFileName.return_value = 'test_open_latex_template_filename', 'filetype' self.form.open_latex_template() self.assertTrue(mock_opendialog.getOpenFileName.called) self.assertEqual(os.path.abspath('test_open_latex_template_filename'), self.form.le_latex_tempate.text()) # Simulate open dialog closed (canceled) mock_opendialog.getOpenFileName.return_value = '', '' self.form.open_latex_template() self.assertTrue(mock_opendialog.getOpenFileName.called) # no change self.assertEqual(os.path.abspath('test_open_latex_template_filename'), self.form.le_latex_tempate.text()) @mock.patch('CoverletterCreator.SettingsHandler.QFileDialog', autospec=True) def test_open_latex_dir(self, mock_opendialog): mock_opendialog.getExistingDirectory.return_value = 'test_open_latex_dir_folder' self.form.open_latex_dir() self.assertTrue(mock_opendialog.getExistingDirectory.called) self.assertEqual(os.path.abspath('test_open_latex_dir_folder'), self.form.le_latex_out_dir.text()) # Simulate open dialog closed (canceled) mock_opendialog.getExistingDirectory.return_value = '' self.form.open_latex_dir() self.assertTrue(mock_opendialog.getExistingDirectory.called) # no change self.assertEqual(os.path.abspath('test_open_latex_dir_folder'), self.form.le_latex_out_dir.text()) @mock.patch('CoverletterCreator.SettingsHandler.QFileDialog', autospec=True) def test_open_text_template(self, mock_opendialog): mock_opendialog.getOpenFileName.return_value = 'test_open_text_template_filename', 'filetype' self.form.open_text_template() self.assertTrue(mock_opendialog.getOpenFileName.called) self.assertEqual(os.path.abspath('test_open_text_template_filename'), self.form.le_text_template.text()) # Simulate open dialog closed (canceled) mock_opendialog.getOpenFileName.return_value = '', '' self.form.open_text_template() self.assertTrue(mock_opendialog.getOpenFileName.called) # no change self.assertEqual(os.path.abspath('test_open_text_template_filename'), self.form.le_text_template.text()) @mock.patch('CoverletterCreator.SettingsHandler.QFileDialog', autospec=True) def test_open_text_dir(self, mock_opendialog): mock_opendialog.getExistingDirectory.return_value = 'test_open_text_dir_folder' self.form.open_text_dir() self.assertTrue(mock_opendialog.getExistingDirectory.called) self.assertEqual(os.path.abspath('test_open_text_dir_folder'), self.form.le_text_out_dir.text()) # Simulate open dialog closed (canceled) mock_opendialog.getExistingDirectory.return_value = '' self.form.open_text_dir() self.assertTrue(mock_opendialog.getExistingDirectory.called) # no change self.assertEqual(os.path.abspath('test_open_text_dir_folder'), self.form.le_text_out_dir.text()) def reset_all_variables(self): # Reset all variables self.form.latex_template = "" self.form.text_template = "" self.form.latex_dir = "" self.form.text_dir = "" self.form.open_pdf = False self.form.open_text = False self.form.keep_tex = False self.form.latex_compiler = "" self.form.latex_custom_command = "" def reset_all_ui_elements(self): self.form.le_latex_tempate.setText("") self.form.le_text_template.setText("") self.form.le_latex_out_dir.setText("") self.form.le_text_out_dir.setText("") self.form.cb_open_pdf_after.setChecked(True) self.form.cb_open_text_after.setChecked(True) self.form.cb_keep_tex.setChecked(True) self.form.combo_latex_compiler.setCurrentText("") self.form.le_custom_latex.setText("")
class MainWindow(QMainWindow): def __init__(self): super(MainWindow, self).__init__() translator = QTranslator() print(QLocale.system().name()) translator.load('qt_' + QLocale.system().name(), QLibraryInfo.location(QLibraryInfo.TranslationsPath)) app.installTranslator(translator) self.setStyleSheet(myStyleSheet(self)) self.MaxRecentFiles = 5 self.windowList = [] self.recentFileActs = [] self.curFile = '' self.setAcceptDrops(True) self.settings = QSettings("QTextEdit", "QTextEdit") self.myeditor = QTextEdit() assert (self.locale().language() == QLocale.German) self.myeditor.setAcceptRichText(False) self.myeditor.setUndoRedoEnabled(True) self.myeditor.setStyleSheet(myStyleSheet(self)) self.myeditor.setContextMenuPolicy(Qt.CustomContextMenu) self.myeditor.customContextMenuRequested.connect( self.contextMenuRequested) self.createActions() self.createToolBars() self.createMenus() self.createStatusBar() self.setWindowIcon(QIcon.fromTheme("gnome-documents")) self.readSettings() self.myeditor.document().contentsChanged.connect( self.documentWasModified) self.setCurrentFile('') self.setCentralWidget(self.myeditor) self.myeditor.setFocus() def closeEvent(self, event): if self.maybeSave(): self.writeSettings() event.accept() else: event.ignore() def newFile(self): if self.maybeSave(): self.myeditor.clear() self.setCurrentFile('') def open(self): if self.maybeSave(): fileName, _ = QFileDialog.getOpenFileName( self, "Datei öffnen", QDir.homePath() + "/Dokumente", "Text Dateien (*.txt *.csv *.sh *.py) ;; alle Dateien (*.*)") if fileName: self.loadFile(fileName) else: self.statusBar().showMessage("abgebrochen", 3000) def save(self): if not self.myeditor.toPlainText() == "": if self.myeditor.document().isModified(): if self.curFile: return self.saveFile(self.curFile) self.setCurrentFile(fileName) else: return self.saveAs() else: self.statusBar().showMessage( "Datei '" + self.curFile + "' bereits gespeichert", 3000) else: self.statusBar().showMessage("kein Text") def saveAs(self): if not self.myeditor.toPlainText() == "": if self.curFile: fileName, _ = QFileDialog.getSaveFileName( self, "Speichern als...", self.curFile, "Text Dateien (*.txt)") else: fileName, _ = QFileDialog.getSaveFileName( self, "Speichern als...", QDir.homePath() + "/Dokumente/Unbenannt.txt", "Text Dateien (*.txt)") if fileName: return self.saveFile(fileName) return False else: self.statusBar().showMessage("kein Text") def contextMenuRequested(self, point): cmenu = QMenu() cmenu = self.myeditor.createStandardContextMenu() if not self.myeditor.textCursor().selectedText() == "": cmenu.addSeparator() cmenu.addAction(QIcon.fromTheme("edit-find-and-replace"), "alle Übereinstimmungen ersetzen", self.replaceThis) cmenu.exec_(self.myeditor.mapToGlobal(point)) def replaceThis(self): if not self.myeditor.textCursor().selectedText() == "": rtext = self.myeditor.textCursor().selectedText() dlg = QInputDialog(self, Qt.Dialog) dlg.setOkButtonText("Replace") text = dlg.getText(self, "Ersetzen", "ersetze '" + rtext + "' durch:", QLineEdit.Normal, "") oldtext = self.myeditor.document().toPlainText() if not (text[0] == ""): newtext = oldtext.replace(rtext, text[0]) self.myeditor.setPlainText(newtext) self.myeditor.document().setModified(True) def about(self): link = "<p><a title='Axel Schneider' href='http://goodoldsongs.jimdo.com' target='_blank'>Axel Schneider</a></p>" title = "über QTextEdit" message = ( "<span style='text-shadow: #2e3436 2px 2px 2px; color: #6169e1; font-size: 24pt;font-weight: bold;'><strong>QTextEdit 1.2</strong></span></p><br><br>created by<h2 >" + link + "</h2> with PyQt5" "<br><br>Copyright © 2018 The Qt Company Ltd and other contributors." "<br>Qt and the Qt logo are trademarks of The Qt Company Ltd.") msg = QMessageBox(QMessageBox.Information, title, message, QMessageBox.NoButton, self, Qt.Dialog | Qt.NoDropShadowWindowHint).show() def documentWasModified(self): self.setWindowModified(self.myeditor.document().isModified()) def createActions(self): self.newAct = QAction(QIcon.fromTheme('document-new'), "&Neu", self, shortcut=QKeySequence.New, statusTip="neue Datei erstellen", triggered=self.newFile) self.openAct = QAction(QIcon.fromTheme('document-open'), "Öffnen.", self, shortcut=QKeySequence.Open, statusTip="Datei öffnen", triggered=self.open) self.saveAct = QAction(QIcon.fromTheme('document-save'), "Speichern", self, shortcut=QKeySequence.Save, statusTip="Dokument speichern", triggered=self.save) self.saveAsAct = QAction( QIcon.fromTheme('document-save-as'), "Speichern als...", self, shortcut=QKeySequence.SaveAs, statusTip="Dokument unter neuem Namen speichern", triggered=self.saveAs) self.exitAct = QAction(QIcon.fromTheme('application-exit'), "Beenden", self, shortcut="Ctrl+Q", statusTip="Programm beenden", triggered=self.close) self.cutAct = QAction(QIcon.fromTheme('edit-cut'), "Ausschneiden", self, shortcut=QKeySequence.Cut, statusTip="Ausschneiden", triggered=self.myeditor.cut) self.copyAct = QAction(QIcon.fromTheme('edit-copy'), "Kopieren", self, shortcut=QKeySequence.Copy, statusTip="Kopieren", triggered=self.myeditor.copy) self.pasteAct = QAction(QIcon.fromTheme('edit-paste'), "Einfügen", self, shortcut=QKeySequence.Paste, statusTip="Einfügen", triggered=self.myeditor.paste) self.undoAct = QAction(QIcon.fromTheme('edit-undo'), "Rückgängig", self, shortcut=QKeySequence.Undo, statusTip="Rückgängig", triggered=self.myeditor.undo) self.redoAct = QAction(QIcon.fromTheme('edit-redo'), "Wiederholen", self, shortcut=QKeySequence.Redo, statusTip="Wiederholen", triggered=self.myeditor.redo) self.aboutAct = QAction(QIcon.fromTheme('help-about'), "Info", self, statusTip="über QTextEdit", triggered=self.about) self.aboutQtAct = QAction(QIcon.fromTheme('help-about'), "über Qt", self, statusTip="über Qt", triggered=QApplication.instance().aboutQt) self.repAllAct = QPushButton("alles ersetzen") self.repAllAct.setIcon(QIcon.fromTheme("edit-find-and-replace")) self.repAllAct.setStatusTip("alles ersetzen") self.repAllAct.clicked.connect(self.replaceAll) self.cutAct.setEnabled(False) self.copyAct.setEnabled(False) self.myeditor.copyAvailable.connect(self.cutAct.setEnabled) self.myeditor.copyAvailable.connect(self.copyAct.setEnabled) self.undoAct.setEnabled(False) self.redoAct.setEnabled(False) self.myeditor.undoAvailable.connect(self.undoAct.setEnabled) self.myeditor.redoAvailable.connect(self.redoAct.setEnabled) ### print preview self.printPreviewAct = QAction("Druckvorschau", self, shortcut=QKeySequence.Print, statusTip="Druckvorschau", triggered=self.handlePrintPreview) self.printPreviewAct.setIcon(QIcon.fromTheme("document-print-preview")) ### print self.printAct = QAction("Drucken", self, shortcut=QKeySequence.Print, statusTip="Dokument drucken", triggered=self.handlePrint) self.printAct.setIcon(QIcon.fromTheme("document-print")) for i in range(self.MaxRecentFiles): self.recentFileActs.append( QAction(self, visible=False, triggered=self.openRecentFile)) def findText(self): word = self.findfield.text() if self.myeditor.find(word): self.statusBar().showMessage("'" + word + "' gefunden", 2000) else: self.myeditor.moveCursor(QTextCursor.Start) if self.myeditor.find(word): return else: self.statusBar().showMessage("nichts gefunden", 3000) def replaceAll(self): oldtext = self.findfield.text() newtext = self.replacefield.text() if not oldtext == "": h = self.myeditor.toHtml().replace(oldtext, newtext) self.myeditor.setText(h) self.setModified(True) self.statusBar().showMessage("alles ersetzt", 3000) else: self.statusBar().showMessage("nichts zu ersetzen", 3000) def replaceOne(self): oldtext = self.findfield.text() newtext = self.replacefield.text() if not oldtext == "": h = self.myeditor.toHtml().replace(oldtext, newtext, 1) self.myeditor.setText(h) self.setModified(True) self.statusBar().showMessage("1 ersetzt", 3000) else: self.statusBar().showMessage("nichts zu ersetzen", 3000) def openRecentFile(self): action = self.sender() if action: if (self.maybeSave()): self.loadFile(action.data()) def createMenus(self): self.fileMenu = self.menuBar().addMenu("&Datei") self.separatorAct = self.fileMenu.addSeparator() self.fileMenu.addAction(self.newAct) self.fileMenu.addAction(self.openAct) self.fileMenu.addAction(self.saveAct) self.fileMenu.addAction(self.saveAsAct) self.fileMenu.addSeparator() for i in range(self.MaxRecentFiles): self.fileMenu.addAction(self.recentFileActs[i]) self.updateRecentFileActions() self.fileMenu.addSeparator() self.clearRecentAct = QAction("Liste löschen", self, triggered=self.clearRecentFiles) self.clearRecentAct.setIcon(QIcon.fromTheme("edit-clear")) self.fileMenu.addAction(self.clearRecentAct) self.fileMenu.addSeparator() self.fileMenu.addAction(self.exitAct) self.editMenu = self.menuBar().addMenu("&Bearbeiten") self.editMenu.addAction(self.undoAct) self.editMenu.addAction(self.redoAct) self.editMenu.addSeparator() self.editMenu.addAction(self.cutAct) self.editMenu.addAction(self.copyAct) self.editMenu.addAction(self.pasteAct) self.menuBar().addSeparator() self.helpMenu = self.menuBar().addMenu("&Hilfe") self.helpMenu.addAction(self.aboutAct) def createToolBars(self): self.fileToolBar = self.addToolBar("Datei") self.fileToolBar.setIconSize(QSize(16, 16)) self.fileToolBar.addAction(self.newAct) self.fileToolBar.addAction(self.openAct) self.fileToolBar.addAction(self.saveAct) self.fileToolBar.addAction(self.saveAsAct) self.fileToolBar.addSeparator() self.fileToolBar.addAction(self.printPreviewAct) self.fileToolBar.addAction(self.printAct) self.fileToolBar.setStyleSheet("QToolBar { border: 0px }") self.fileToolBar.setMovable(False) self.setContextMenuPolicy(Qt.NoContextMenu) self.editToolBar = self.addToolBar("Bearbeiten") self.editToolBar.setIconSize(QSize(16, 16)) self.editToolBar.addAction(self.undoAct) self.editToolBar.addAction(self.redoAct) self.editToolBar.addSeparator() self.editToolBar.addAction(self.cutAct) self.editToolBar.addAction(self.copyAct) self.editToolBar.addAction(self.pasteAct) self.editToolBar.setMovable(False) self.editToolBar.setStyleSheet("QToolBar { border: 0px }") ### find / replace toolbar self.addToolBarBreak() self.findToolBar = self.addToolBar("Suchen") self.findToolBar.setIconSize(QSize(16, 16)) self.findfield = QLineEdit() self.findfield.addAction(QIcon.fromTheme("edit-find"), 0) self.findfield.setClearButtonEnabled(True) self.findfield.setFixedWidth(200) self.findfield.setPlaceholderText("suchen") self.findfield.setStatusTip("drücke RETURN zum suchen") self.findfield.setText("") self.findfield.returnPressed.connect(self.findText) self.findToolBar.addWidget(self.findfield) self.replacefield = QLineEdit() self.replacefield.addAction(QIcon.fromTheme("edit-find-replace"), 0) self.replacefield.setClearButtonEnabled(True) self.replacefield.setFixedWidth(200) self.replacefield.setPlaceholderText("ersetzen durch") self.replacefield.setStatusTip( "drücke RETURN um das erste zu ersetzen") self.replacefield.returnPressed.connect(self.replaceOne) self.findToolBar.addSeparator() self.findToolBar.addWidget(self.replacefield) self.findToolBar.addSeparator() self.findToolBar.addWidget(self.repAllAct) self.findToolBar.setMovable(False) self.findToolBar.setStyleSheet("QToolBar { border: 0px }") def createStatusBar(self): self.statusBar().setStyleSheet(myStyleSheet(self)) self.statusBar().showMessage("Willkommen") self.DigitalClock = DigitalClock() self.DigitalClock.setStyleSheet( "QLCDNumber {padding: 2px, 2px 2px 2px; border: 0px solid #2e3436; color: #3465a4; background-color: transparent }" ) self.statusBar().addPermanentWidget(self.DigitalClock) def readSettings(self): pos = self.settings.value("pos", QPoint(200, 200)) size = self.settings.value("size", QSize(400, 400)) self.resize(size) self.move(pos) def writeSettings(self): self.settings.setValue("pos", self.pos()) self.settings.setValue("size", self.size()) def maybeSave(self): if self.myeditor.document().isModified(): ret = QMessageBox.warning( self, "QTextEdit Meldung", "Das Dokument wurde geändert.\nSollen die Änderungen gespeichert werden?", QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel, defaultButton=QMessageBox.Save) if ret == QMessageBox.Save: return self.save() if ret == QMessageBox.Cancel: return False return True def loadFile(self, fileName): file = QFile(fileName) if not file.open(QFile.ReadOnly | QFile.Text): QMessageBox.warning( self, "Meldung", "Cannot read file %s:\n%s." % (fileName, file.errorString())) return infile = QTextStream(file) QApplication.setOverrideCursor(Qt.WaitCursor) self.myeditor.setPlainText(infile.readAll()) QApplication.restoreOverrideCursor() self.setCurrentFile(fileName) self.statusBar().showMessage("Datei '" + fileName + "' geladen", 3000) def saveFile(self, fileName): file = QFile(fileName) if not file.open(QFile.WriteOnly | QFile.Text): QMessageBox.warning( self, "Message", "Cannot write file %s:\n%s." % (fileName, file.errorString())) return False outfile = QTextStream(file) QApplication.setOverrideCursor(Qt.WaitCursor) outfile << self.myeditor.toPlainText() QApplication.restoreOverrideCursor() self.setCurrentFile(fileName) self.statusBar().showMessage("Datei '" + fileName + "' gespeichert", 3000) return True def setCurrentFile(self, fileName): self.curFile = fileName self.myeditor.document().setModified(False) self.setWindowModified(False) if self.curFile: self.setWindowTitle(self.strippedName(self.curFile) + "[*]") else: self.setWindowTitle('Unbenannt.txt' + "[*]") files = self.settings.value('recentFileList', []) if not files == "": try: files.remove(fileName) except ValueError: pass if fileName: files.insert(0, fileName) del files[self.MaxRecentFiles:] self.settings.setValue('recentFileList', files) self.updateRecentFileActions() def updateRecentFileActions(self): mytext = "" files = self.settings.value('recentFileList', []) numRecentFiles = min(len(files), self.MaxRecentFiles) # if not files == "": for i in range(numRecentFiles): text = "&%d %s" % (i + 1, self.strippedName(files[i])) self.recentFileActs[i].setText(text) self.recentFileActs[i].setData(files[i]) self.recentFileActs[i].setVisible(True) self.recentFileActs[i].setIcon(QIcon.fromTheme("text-x-generic")) for j in range(numRecentFiles, self.MaxRecentFiles): self.recentFileActs[j].setVisible(False) self.separatorAct.setVisible((numRecentFiles > 0)) def clearRecentFiles(self, fileName): self.settings.clear() self.updateRecentFileActions() def strippedName(self, fullFileName): return QFileInfo(fullFileName).fileName() def msgbox(self, message): QMessageBox.warning(self, "Message", message) def handlePrint(self): if self.myeditor.toPlainText() == "": self.statusBar().showMessage("kein Text zum Drucken") self.msgbox("kein Text zum Drucken") else: dialog = QtPrintSupport.QPrintDialog() if dialog.exec_() == QDialog.Accepted: self.handlePaintRequest(dialog.printer()) self.statusBar().showMessage("Dokument gedruckt") def handlePrintPreview(self): if self.myeditor.toPlainText() == "": self.statusBar().showMessage("kein Text für Vorschau") self.msgbox("kein Text für Vorschau") else: dialog = QtPrintSupport.QPrintPreviewDialog() dialog.setGeometry(10, 0, self.width() - 60, self.height() - 60) dialog.paintRequested.connect(self.handlePaintRequest) dialog.exec_() self.statusBar().showMessage("Vorschau geschlossen") def handlePaintRequest(self, printer): printer.setDocName(self.curFile) document = self.myeditor.document() document.print_(printer) def dragEnterEvent(self, event): if event.mimeData().hasUrls(): event.accept() else: event.ignore() def dropEvent(self, event): f = str(event.mimeData().urls()[0].toLocalFile()) self.loadFile(f)
class Backup: ''' A utility to store and restore settings for use in testing. Be careful not to lose data. ''' setname = 'settings.zst' def __init__(self, backuploc=None, theDate=None): ''' Store the directory settings in self. The initial strings for the DB are in settings. If initialize is called, they are gone. Likeise, restoration will depend on reinitializing settings ''' self.settings = QSettings('zero_substance', 'structjour') self.apisettings = QSettings('zero_substance/stockapi', 'structjour') self.chartsettings = QSettings('zero_substance/chart', 'structjour') if backuploc is None: if not os.path.exists(self.settings.value('journal')): msg = f"Journal location {self.settings.value('journal')} does not exist" logging.error(msg) raise ValueError(msg) self.rootdir = os.path.normpath( os.path.join(self.settings.value('journal'), 'backup')) else: self.rootdir = backuploc d = pd.Timestamp( theDate) if theDate is not None else pd.Timestamp.now() self.bdir = os.path.join(self.rootdir, d.strftime("backup_%Y%m%d_%H.%M.%S")) self.bu_settings = os.path.join(self.bdir, self.setname) self.dbtrade = self.settings.value('tradeDb') self.dbstructjour = self.settings.value('structjourDb') self.setkeys = [] self.setvals = [] self.apisetkeys = [] self.apisetvals = [] # print(self.bu_settings) def initializeSettings(self): ''' Remove all settings except zero_substance/structjour/journal ''' for key in self.settings.allKeys(): if key != 'journal': self.settings.remove(key) self.apisettings.clear() self.chartsettings.clear() self.settings.sync() self.apisettings.sync() self.chartsettings.sync() def createDir(self): try: if not os.path.exists(self.rootdir): os.mkdir(self.rootdir) if not os.path.exists(self.bdir): os.mkdir(self.bdir) except Exception as ex: logging.error(ex) logging.error('Failed to create backup directory. ' + str(ex)) raise ValueError(ex) pass def removePickle(self): if os.path.exists(self.bu_settings): os.remove(self.bu_settings) def initializeVars(self): self.setkeys = [] self.setvals = [] self.apisetkeys = [] self.apisetvals = [] self.chartkeys = [] self.chartvals = [] def backupDatabase(self, theDir=None): ''' Helper method for backup. If either db file is not found, change the backup dir name to include 'FAILED'. That will prevent a bad restore and retain files and settings in the directory ''' self.bdir = self.bdir if theDir is None else theDir if not os.path.exists(self.bdir): raise ValueError(f'Backup directory {self.bdir} does not exist') dbtrade2 = os.path.split(self.dbtrade)[1] dbstructjour2 = os.path.split(self.dbstructjour)[1] dbtrade2 = os.path.normpath(os.path.join(self.bdir, dbtrade2)) dbstructjour2 = os.path.normpath(os.path.join(self.bdir, dbstructjour2)) try: copyfile(self.dbtrade, dbtrade2) except FileNotFoundError: logging.error( f'Trade database does not exist at {self.dbtrade} and cannot be copied' ) changebdir = self.bdir[0:-17] + "FAILED_" + self.bdir[-17:] os.rename(self.bdir, changebdir) self.bdir = changebdir dbstructjour2 = os.path.normpath( os.path.join(self.bdir, os.path.split(dbstructjour2)[1])) else: logging.info(f'Trade database has been backed up to {dbtrade2}') if dbtrade2 != dbstructjour2: logging.info(f'Trade database has been backed up to {dbtrade2}') try: copyfile(self.dbstructjour, dbstructjour2) except FileNotFoundError: logging.error( f'Structjour database does not exist at {self.dbstructjour} and cannot be copied' ) if self.bdir.find('FAILED_') == -1: changedir = self.bdir[0:-17] + "FAILED_" + self.bdir[-17:] os.rename(self.bdir, changedir) else: logging.info( f'Structjour database has been backed up to {dbstructjour2}' ) def restoreDatabase(self, theDir=None): self.bdir = self.bdir if theDir is None else theDir if not os.path.exists(self.bdir): raise ValueError(f'Backup directory {self.bdir} does not exist.') dbtrade = self.settings.value('tradeDb') dbstructjour = self.settings.value('structjourDb') dbt = os.path.join(self.bdir, os.path.split(dbtrade)[1]) dbs = os.path.join(self.bdir, os.path.split(dbstructjour)[1]) if os.path.exists(dbt): copyfile(dbt, dbtrade) logging.info(f'Db restored {dbt}') else: logging.error(f'Backup file {dbt} does not exist.') if dbs != dbt: if os.path.exists(dbs): copyfile(dbs, dbstructjour) logging.info(f'Db restored {dbs}') else: logging.error(f'Backup file {dbt} does not exist.') def storeSettings(self, replacePickle=False): self.createDir() if os.path.exists(self.bu_settings): if not replacePickle: return self.initializeVars() self.setkeys = self.settings.allKeys() for k in self.setkeys: self.setvals.append(self.settings.value(k)) self.apisetkeys = self.apisettings.allKeys() for k in self.apisetkeys: self.apisetvals.append(self.apisettings.value(k)) self.chartkeys = self.chartsettings.allKeys() for k in self.chartkeys: self.chartvals.append(self.chartsettings.value(k)) setsnkeys = [ self.setkeys, self.setvals, self.apisetkeys, self.apisetvals, self.chartkeys, self.chartvals ] with open(self.bu_settings, "wb") as f: '''Cannot pickle qsettings objects- so we pickle a list''' pickle.dump((setsnkeys), f) logging.info( f'Settings have been backed up to file {self.bu_settings}') def restoreSettings(self, theDir=None): theDir = self.mostRecent() if theDir is None else theDir bu_settings = os.path.join(theDir, self.setname) if os.path.exists(bu_settings): with open(bu_settings, "rb") as f: setsnkeys = pickle.load(f) for k, v in zip(setsnkeys[0], setsnkeys[1]): self.settings.setValue(k, v) for k2, v2 in zip(setsnkeys[2], setsnkeys[3]): self.apisettings.setValue(k2, v2) for k2, v2 in zip(setsnkeys[4], setsnkeys[5]): self.chartsettings.setValue(k2, v2) logging.info(f'Settings backed up to file {bu_settings}') else: logging.error(f'No settings backup found at {bu_settings}') def backup(self): self.storeSettings() self.backupDatabase() def restore(self, theDir=None): self.bdir = self.mostRecent() if theDir is None else theDir self.bdir = os.path.normpath(self.bdir) if not os.path.exists(self.bdir): raise ValueError(f'Backup directory {self.bdir} does not exist') self.restoreSettings(self.bdir) self.restoreDatabase(self.bdir) def mostRecent(self): thedirs = os.listdir(self.rootdir) maxdate = '' maxdir = None for thedir in thedirs: if thedir.startswith('backup_2'): d = thedir[7:].replace('.', ':') if d > maxdate: maxdir = thedir return os.path.join(self.rootdir, maxdir) if maxdir is not None else '' def _clearJournalDir(self): '''For Testing ONLY. TODO implement a seperate backup/restore for this one string''' # jdir = self.settings('journal') self.settings.remove('journal') def _restoreJournalDir(self): '''For Testing''' pass
class RedirectSettingsWidget(QWidget): def __init__(self, page): super().__init__() self.page = page self.init_ui() def init_ui(self): self.layout = QVBoxLayout() self.settings = QSettings("redirect_settings", "GP_IVR_Settings") self.error = False self.setup_heading() self.voiceflow_settings = QSettings("simplified_voiceflow", "GP_IVR_Settings") self.redirect_numbers = {} self.setup_redirects_form() self.init_settings() self.setup_buttons() self.layout.addWidget(QLabel()) self.layout.addLayout(self.button_layout) self.setLayout(self.layout) def setup_buttons(self): self.button_layout = QHBoxLayout() if not self.page == "project": back_button_creator = BackButton() self.back_button = back_button_creator.create_back_button() self.button_layout.addWidget(self.back_button) else: self.button_layout.addWidget(QLabel()) self.apply_settings_button = QPushButton("Apply") self.apply_settings_button.setToolTip("Update telephone numbers that users calling the IVR are redirected to") self.button_layout.addWidget(self.apply_settings_button) def setup_heading(self): heading_font = QFont('Arial', 12) heading_font.setBold(True) rules_font = QFont('Arial', 10) rules_font.setItalic(True) self.layout.addWidget(QLabel()) heading = QLabel("Redirect Phone Numbers:") heading.setFont(heading_font) self.layout.addWidget(heading) page_info = QLabel( "Here you can change the phone numbers that users are redirected\nto after reaching particular message end-points in the IVR.\nIf you don't want a user redirected, leave the value blank.") self.layout.addWidget(page_info) self.layout.addWidget(QLabel()) uk_number_rules = QLabel("* UK Numbers Only") uk_number_rules.setFont(rules_font) self.layout.addWidget(uk_number_rules) no_extension_rule = QLabel("* Don't add Extension") no_extension_rule.setFont(rules_font) self.layout.addWidget(no_extension_rule) def init_settings(self): provider_number = self.settings.value("provider number") if provider_number: self.provider_number.setText(provider_number) for node in self.redirect_numbers: node_value = self.settings.value(node) if node_value: self.redirect_numbers[node].setText(node_value) def setup_redirects_form(self): voiceflow_settings = GetVoiceflowSettings(self.voiceflow_settings.value("simplified json")) redirect_texts = voiceflow_settings.get_redirect_texts() if redirect_texts == -1: msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText("Error\n\nYou have not set up an IVR") msg.setWindowTitle("Error") msg.exec_() return self.provider_number = QLineEdit() self.provider_number.setToolTip("Enter the telephone number users should call to access your IVR - you must own this number") self.button_group = QGroupBox() self.layout.addWidget(self.button_group) self.v_box = QHBoxLayout() self.button_group.setLayout(self.v_box) self.v_box.addWidget(QLabel("Provider Telephone Number:")) self.v_box.addWidget(self.provider_number, alignment=Qt.AlignRight) for node in redirect_texts: self.add_redirects(redirect_texts[node], node) def add_redirects(self, redirect_text, redirect_node): redirect_text = QLabel(redirect_text) redirect_text.setWordWrap(True) redirect_number = QLineEdit() redirect_number.setToolTip("Enter a UK telephone number without extension") self.button_group = QGroupBox() self.layout.addWidget(self.button_group) self.v_box = QHBoxLayout() self.button_group.setLayout(self.v_box) self.v_box.addWidget(redirect_text) grow_label = QLabel() self.v_box.addWidget(grow_label) grow_label.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding) self.v_box.addWidget(redirect_number, alignment=Qt.AlignRight) self.redirect_numbers[redirect_node] = redirect_number def apply_settings(self): self.save_settings() phone_numbers = [] node_ids = [] if not self.provider_number.text().isnumeric(): msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText("Error\n\nProvider Number is Not in Correct Format") msg.setWindowTitle("Error") msg.exec_() self.error = True return for node in self.redirect_numbers: node_ids.append(node) if not self.redirect_numbers[node].text().isnumeric(): if not self.redirect_numbers[node].text(): phone_numbers.append("-1") continue msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setText("Error\n\nPhone Number is Not in Correct Format") msg.setWindowTitle("Error") msg.exec_() return phone_numbers.append(self.redirect_numbers[node].text()) modify_dialplan = SettingsToDialplan(asterisk_constants.EXTENSIONS_CONF_PATH, node_ids, phone_numbers, self.provider_number.text()) modify_dialplan.configure_dialplan() def save_settings(self): self.settings.clear() self.settings.setValue("provider number", self.provider_number.text()) for node in self.redirect_numbers: self.settings.setValue(node, self.redirect_numbers[node].text())
# persepolis --clear >> remove config_folder if args.clear: from persepolis.scripts.data_base import PersepolisDB # create an object for PersepolisDB persepolis_db = PersepolisDB() # Reset data base persepolis_db.resetDataBase() # close connections persepolis_db.closeConnections() # Reset persepolis_setting persepolis_setting = QSettings('persepolis_download_manager', 'persepolis') persepolis_setting.clear() persepolis_setting.sync() sys.exit(0) # persepolis --default >> remove persepolis setting. if args.default: persepolis_setting = QSettings('persepolis_download_manager', 'persepolis') persepolis_setting.clear() persepolis_setting.sync() print('Persepolis restored default') sys.exit(0) if args.link: add_link_dictionary['link'] = "".join(args.link)
app = QApplication(sys.argv) app.setOrganizationName("PGDP") app.setOrganizationDomain("pgdp.net") app.setApplicationName("PPQT2") from PyQt5.QtCore import QSettings settings = QSettings() # load a list of one or more lines as a metadata section import metadata import utilities import mainwindow import book import dictionaries settings = QSettings() settings.clear() settings.setValue("paths/dicts_path",files_path) settings.setValue("dictionaries/default_tag","en_GB") import dictionaries dictionaries.initialize(settings) def load_section(mgr, section, line_list, vers=None): stream = utilities.MemoryStream() if vers : stream << metadata.open_line(C.MD_V, vers) stream << metadata.open_line(section) for line in line_list: stream.writeLine(line) stream << metadata.close_line(section) stream.rewind() mgr.load_meta(stream)
sys.path.append(ppqt_path) from PyQt5.QtWidgets import QApplication app = QApplication(sys.argv) app.setOrganizationName("PGDP") app.setOrganizationDomain("pgdp.net") app.setApplicationName("PPQT2") from PyQt5.QtCore import QSettings settings = QSettings() import constants as C import colors from PyQt5.QtGui import (QColor,QBrush, QTextCharFormat) # check initialize # check defaults on empty settings settings.clear() colors.initialize(settings) colors.shutdown(settings) assert settings.value('colors/spell_color') == '#ff00ff' # == magenta assert settings.value('colors/spell_style') == QTextCharFormat.WaveUnderline assert settings.value('colors/scanno_color') == '#d8bfd8' # == 'thistle' assert settings.value('colors/scanno_style') == QTextCharFormat.NoUnderline assert settings.value('colors/current_line') == '#fafae0' assert settings.value('colors/find_range') == "#ccffff" assert settings.value('colors/modified_name') == '#ff0000' # == 'red' # make some changes SIGCOUNT = 0 def dingdong(): global SIGCOUNT SIGCOUNT += 1
class TestCoverletterCreator(TestCase): def setUp(self): # Start app fresh self.qsettings = QSettings() self.qsettings.clear() self.cc = CoverletterCreator() self.cc.show() def tearDown(self): self.cc.file_dirty = False # To not trigger "are you sure?" popup self.cc.close() ''' def test_connect_all_fields(self): self.fail() def test_connect_mandatory_fields(self): self.fail() def test_label_clicked(self): self.fail() def test_checkbox_clicked(self): self.fail() def test_combobox_clicked(self): self.fail() def test_setWindowTitleUnsaved(self): self.fail() def test_setWindowTitleSaved(self): self.fail() def test_new_project(self): self.fail() def test_reset_all_fields(self): self.fail() def test_save_project(self): self.fail() def test_generate_root(self): self.fail() def test_saveas_project(self): self.fail() def test_open_project(self): self.fail() def test_load_file(self): self.fail() ''' @mock.patch('CoverletterCreator.coverletter_creator.QFileDialog', autospec=True) @mock.patch('CoverletterCreator.coverletter_creator.QtWidgets.QMessageBox.information') def test_browse_and_get_photo(self, mock_error, mock_opendialog): from PyQt5 import QtGui # Valid photo path mock_opendialog.getOpenFileName.return_value = 'Latex/Resources/profile.png', 'file_type' self.cc.label_pic.clear() self.cc.browse_photo() self.assertEqual("Latex/Resources/profile.png", self.cc.PHOTOPATH.text()) self.assertIsInstance(self.cc.label_pic.pixmap(), QtGui.QPixmap) # invalid photo path mock_opendialog.getOpenFileName.return_value = 'invalid.png', 'file_type' self.cc.browse_photo() # ensure no change on set path self.assertEqual("Latex/Resources/profile.png", self.cc.PHOTOPATH.text()) assert mock_error.called @mock.patch('CoverletterCreator.coverletter_creator.PdfCreator') @mock.patch('CoverletterCreator.coverletter_creator.QtWidgets.QMessageBox.critical' ) def test_generate_pdf(self, mock_error, mock_pdfcreator): self.cc.settings.latex_template = "test_generate_latex_template" self.cc.settings.latex_dir = "test_generate_latex_dir" self.cc.settings.open_pdf = True self.cc.generate_pdf() assert mock_pdfcreator.called assert mock_pdfcreator().read_template.called mock_pdfcreator().read_template.assert_called_with(template="test_generate_latex_template") assert mock_pdfcreator().convert_to_dict.called assert mock_pdfcreator().render_template.called assert mock_pdfcreator().compile_xelatex.called mock_pdfcreator().compile_xelatex.side_effect = FileNotFoundError self.cc.generate_pdf() assert mock_error.called @mock.patch('CoverletterCreator.coverletter_creator.TextCreator') @mock.patch('CoverletterCreator.coverletter_creator.QtWidgets.QMessageBox.critical' ) def test_generate_text(self,mock_error, mock_textcreator): self.cc.settings.text_template = "test_generate_text_template" self.cc.settings.text_dir = "test_generate_text_dir" self.cc.settings.open_text = True self.cc.generate_text() assert mock_textcreator.called assert mock_textcreator().read_template.called mock_textcreator().read_template.assert_called_with(template="test_generate_text_template") assert mock_textcreator().convert_to_dict.called assert mock_textcreator().render_template.called assert mock_textcreator().compile_text.called mock_textcreator().compile_text.assert_called_with(open_text=True, outputDir='test_generate_text_dir', textname=mock.ANY) mock_textcreator().read_template.side_effect = FileNotFoundError self.cc.generate_text() assert mock_error.called def test_writeSettings(self): self.cc.filename = "test_writeSettings_filename" # Set file not modified self.cc.file_dirty = False self.cc.writeSettings() self.qsettings.beginGroup("Project") self.assertEqual("test_writeSettings_filename", self.qsettings.value("filename")) self.qsettings.endGroup() self.cc.filename = "test_writeSettings_filename_modified" # Set file modified self.cc.file_dirty = True self.cc.writeSettings() self.qsettings.beginGroup("Project") # Settings not changed because file has not been saved self.assertEqual("test_writeSettings_filename", self.qsettings.value("filename")) self.qsettings.endGroup() def test_readSettings(self): self.qsettings.beginGroup("Project") self.qsettings.setValue("filename", "test_readSettings_filename") self.qsettings.endGroup() self.cc.readSettings() self.assertEqual("test_readSettings_filename", self.cc.filename)