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 _clearSettings(self):
"""
Just clears all peacock settings.
"""
settings = QSettings()
settings.clear()
settings.sync()
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 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))
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 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()
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 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)
