def verify_email_confirmation(self, code: str) -> Union[str, None]:
'''
If the corresponding email verification exist, create such user.
If not - throws an exception
'''
self.cursor.execute(
f"SELECT * FROM EmailVerification WHERE `verification_hash` = '{code}'"
)
on_failed = Settings.failed_email_verification_link()
on_valid = Settings.vaild_email_verification_link()
try:
(_, email, password, date) = self.cursor.fetchone()
except TypeError:
raise EmailValidationError(-1204, 'No such verification code exists or it was already used.', on_failed)
if (datetime.now() - datetime.strptime(date, "%Y-%m-%d %H:%M:%S.%f")) > timedelta(hours=24):
raise EmailValidationError(-1203, 'Email verification time has passed.', on_failed)
if self.check_user_exists(email):
raise EmailValidationError(-1200, 'Email is already in use.', on_failed)
self.logger.debug(f'New user `{email}` has successfuly confirmed his email and created an account')
self.create_user(email, password)
return on_valid
def __init__(self, parent, args):
QtCore.QThread.__init__(self, parent)
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.qt_app = parent
self.scene.warmup()
self.aubio_connector = None
if not self.args.noaudio:
self.aubio_thread = QtCore.QThread()
self.aubio_thread.start()
self.aubio_connector = AubioConnector()
self.aubio_connector.onset_detected.connect(
self.mixer.onset_detected)
self.aubio_connector.fft_data.connect(
self.mixer.audio.update_fft_data)
self.aubio_connector.pitch_data.connect(
self.mixer.audio.update_pitch_data)
self.aubio_connector.moveToThread(self.aubio_thread)
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
def test_set_get(self):
"Sets and gets values."
x = Settings()
x.a = 1
x.b = 2
self.assertEqual(x.a, 1)
self.assertEqual(x.b, 2)
class FireMixApp(QtCore.QThread):
"""
Main logic of FireMix. Operates the mixer tick loop.
"""
def __init__(self, args, parent=None):
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
# Create the default layer.
default_playlist = Playlist(self, self.args.playlist, 'last_playlist')
default_layer = Layer(self, 'default')
default_layer.set_playlist(default_playlist)
self.mixer.add_layer(default_layer)
if self.args.speech_layer:
speech_playlist = Playlist(self, self.args.speech_playlist, 'last_speech_playlist')
speech_layer = Layer(self, 'speech')
speech_layer.set_playlist(speech_playlist)
self.mixer.add_layer(speech_layer)
if self.args.route_layer:
route_playlist = Playlist(self, self.args.route_playlist, 'last_route_playlist')
route_layer = Layer(self, 'routes')
route_layer.set_playlist(route_playlist)
self.mixer.add_layer(route_layer)
self.scene.warmup()
self.aubio_connector = None
if not self.args.noaudio:
self.aubio_connector = AubioConnector()
self.aubio_connector.onset_detected.connect(self.mixer.onset_detected)
self.osc_server = None
if not self.args.noosc:
self.osc_server = OscServer(
self.args.osc_port, self.args.mixxx_osc_port, self.mixer)
self.osc_server.start()
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
QtCore.QThread.__init__(self, parent)
def run(self):
self._running = True
self.mixer.run()
def stop(self):
self._running = False
self.mixer.stop()
self.mixer.save()
self.settings.save()
def onBatch1(self):
dfilename = askdirectory()
if dfilename:
pickles = []
for filename in glob.glob(os.path.join(dfilename, '*.py')):
module = import_file(filename)
if module:
basename = os.path.basename(filename)
root, ext = os.path.splitext(basename)
logging.debug(root)
BRANCH = Settings(root)
pickles.append(BRANCH.get_filename())
for i in dir(module):
if i[0] != '_':
value = getattr(module, i)
if isinstance(value, all_types):
BRANCH.set(i, value)
message = "Processed pickles:\n" + plain(pickles) + "\n\n" +\
"Note: Empty pickles was not created!"
showinfo("Info", message)
self.setText()
self.setStatus()
def onBatch1(self):
dfilename = askdirectory()
if dfilename:
pickles = []
for filename in glob.glob(os.path.join(dfilename, '*.py')):
module = import_file(filename)
if module:
basename = os.path.basename(filename)
root, ext = os.path.splitext(basename)
logging.debug(root)
BRANCH = Settings(root)
pickles.append(BRANCH.get_filename())
for i in dir(module):
if i[0] != '_':
value = getattr(module, i)
if isinstance(value, all_types):
BRANCH.set(i, value)
message = "Processed pickles:\n" + plain(pickles) + "\n\n" +\
"Note: Empty pickles was not created!"
showinfo("Info", message)
self.setText()
self.setStatus()
def test_callable_overwrite_with_callable(self):
"Allows overwriting a callable with a callable."
x = Settings()
x.a = lambda s: s.init + " original"
x.a = lambda s: s.a + " and derived"
x.init = "init"
self.assertEqual(x.a, "init original and derived")
def test_list_validity(self):
Settings._list_validity_check(['x','y'], ['x','y','z'])
Settings._list_validity_check(['x','y'], ['x','y','z'])
with self.assertRaises(InvalidSettingError):
Settings._list_validity_check(['a','y'], ['x','y','z'])
Settings._list_validity_check([['x','y'],['a']], [['b','a'],['x','y','z']])
with self.assertRaises(InvalidSettingError):
Settings._list_validity_check([['x','y'],['c']], [['b','a'],['x','y','z']])
def test_ctor_with_settings_file(self):
s = Settings('foo_settings.json',
{'foo':[0, 1], 'bar':['barval', 'barval2']})
with self.assertRaises(InvalidSettingError):
Settings('foo_settings.json',
{'foo':[0, 2], 'bar':['barval', 'barval2']})
with self.assertRaises(InvalidSettingError):
Settings('foo_settings.json',
{'foo':[0, 1], 'bar':['barval2', 'barval3']})
def test_no_callable_overwrite_non_callable(self):
"Disallows overwriting a callable with non-callable."
x = Settings()
x.a = lambda s: 1
with self.assertRaisesRegex(
AttributeError, "^trying to override attribute 'a' "
"from a callable value to a non-callable "
"one"):
x.a = 1
def setUp(self):
self.settings = Settings({'foo': 1, 'bar': 'barval'},
{'foo': [1], 'bar': ['barval']})
self.empty_settings = Settings({}, {})
self.same = Settings({'bar': 'barval', 'foo': 1},
{'foo': [1], 'bar': ['barval']})
self.slightly_diff = Settings({'bar': 'barval', 'fooo': 1},
{'fooo': [1], 'bar': ['barval']})
dammit.keep_fkn_trying(self.create_foo_settings_json)
def test_cannot_set_parent_or_attrs(self):
"Cannot set the attributes 'parent' or 'attrs'."
x = Settings()
with self.assertRaisesRegex(AttributeError,
"'parent' is a reserved name"):
x.parent = 1
with self.assertRaisesRegex(AttributeError,
"'attrs' is a reserved name"):
x.attrs = 1
class FireMixApp(QtCore.QThread):
"""
Main logic of FireMix. Operates the mixer tick loop.
"""
def __init__(self, args, parent=None):
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
# Create the default layer.
default_playlist = Playlist(self, self.args.playlist, 'last_playlist')
default_layer = Layer(self, 'default')
default_layer.set_playlist(default_playlist)
self.mixer.add_layer(default_layer)
if self.args.speech_layer:
speech_playlist = Playlist(self, self.args.speech_playlist,
'last_speech_playlist')
speech_layer = Layer(self, 'speech')
speech_layer.set_playlist(speech_playlist)
self.mixer.add_layer(speech_layer)
self.scene.warmup()
self.aubio_connector = None
if not self.args.noaudio:
self.aubio_connector = AubioConnector()
self.aubio_connector.onset_detected.connect(
self.mixer.onset_detected)
self.osc_server = None
if not self.args.noosc:
self.osc_server = OscServer(self.args.osc_port,
self.args.mixxx_osc_port, self.mixer)
self.osc_server.start()
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
QtCore.QThread.__init__(self, parent)
def run(self):
self._running = True
self.mixer.run()
def stop(self):
self._running = False
self.mixer.stop()
self.mixer.save()
self.settings.save()
def onLoadFile(self):
initialdir = os.path.expanduser("~")
filename = askopenfilename(initialdir=initialdir,
filetypes=[
('Config files', '*.pickle'),
('All files', '*.*'),
])
if filename:
self.s = Settings(filename=filename)
self.showInfo()
def test_list_with_dict(self):
self.assertTrue(Settings._is_in_list(
[{'a':'d'}],
[{'a':['d']}]))
self.assertTrue(Settings._is_in_list(
[{'a':{'c': 'd', 'h': 'i'}, 'e': 'f'}],
[{'e':['f'],'a':{'h':['i'],'c':['d']}}]))
self.assertTrue(Settings._is_in_list(
[['y'],[{'f':'g','j':'k'}]],
[['y', 'z'],[{'j':['k'],'f':['g']}]]))
self.assertTrue(Settings._is_in_list(
[[[[['b', {'a': {'c':'d','h':'i'}, 'e':'f'}], ['y'], [{'f':'g', 'j':'k'}]]]]],
[[[[['y', 'z'], [{'e': ['f'], 'a': {'h': ['i'], 'c': ['d']}}, 'a', 'b', 'c'], [{'j': ['k'], 'f': ['g']}]]]]]))
self.assertFalse(Settings._is_in_list(
[[[[['f', {'a': {'c': 'd'}}], ['y'], [{'f': 'g'}]]]]],
[[[[['y', 'z'], [{'e': ['f'], 'a': {'h': ['i'], 'c': ['d']}}, 'a', 'b', 'c'], [{'j': ['k'], 'f': ['g']}]]]]]))
self.assertFalse(Settings._is_in_list(
[[[[[{'a': {'c': 'd'}}], ['yy'], [{'f': 'g'}]]]]],
[[[[['y', 'z'], [{'e': ['f'], 'a': {'h': ['i'], 'c': ['d']}}, 'a', 'b', 'c'], [{'j': ['k'], 'f': ['g']}]]]]]))
self.assertFalse(Settings._is_in_list(
[[[[[{'a': {'c': 'd'}}], ['y'], [{'f': 'h'}]]]]],
[[[[['y', 'z'], [{'e': ['f'], 'a': {'h': ['i'], 'c': ['d']}}, 'a', 'b', 'c'], [{'j': ['k'], 'f': ['g']}]]]]]))
self.assertFalse(Settings._is_in_list(
[[[{'a': {'c': 'e'}}]]],
[[[{'e': ['f'], 'a': {'h': ['i'], 'c': ['d']}}, 'a', 'b', 'c']]]))
self.assertFalse(Settings._is_in_list(
[[[[[{'a': {'c': 'e'}}], ['y'], [{'f': 'g'}]]]]],
[[[[['y', 'z'], [{'e': ['f'], 'a': {'h': ['i'], 'c': ['d']}}, 'a', 'b', 'c'], [{'j': ['k'], 'f': ['g']}]]]]]))
class FireMixApp(QtCore.QThread):
"""
Main logic of FireMix. Operates the mixer tick loop.
"""
playlist_changed = QtCore.Signal()
def __init__(self, parent, args):
QtCore.QThread.__init__(self, parent)
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.qt_app = parent
self.scene.warmup()
self.aubio_connector = None
if not self.args.noaudio:
self.aubio_thread = QtCore.QThread()
self.aubio_thread.start()
self.aubio_connector = AubioConnector()
self.aubio_connector.onset_detected.connect(
self.mixer.onset_detected)
self.aubio_connector.fft_data.connect(
self.mixer.audio.update_fft_data)
self.aubio_connector.pitch_data.connect(
self.mixer.audio.update_pitch_data)
self.aubio_connector.moveToThread(self.aubio_thread)
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
def run(self):
self._running = True
self.mixer.run()
def stop(self):
self._running = False
self.aubio_thread.quit()
self.mixer.stop()
self.playlist.save()
self.settings.save()
class FireMixApp(QtCore.QThread):
"""
Main logic of FireMix. Operates the mixer tick loop.
"""
playlist_changed = QtCore.Signal()
def __init__(self, parent, args):
QtCore.QThread.__init__(self, parent)
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.qt_app = parent
self.scene.warmup()
self.aubio_connector = None
if not self.args.noaudio:
self.aubio_thread = QtCore.QThread()
self.aubio_thread.start()
self.aubio_connector = AubioConnector()
self.aubio_connector.onset_detected.connect(self.mixer.onset_detected)
self.aubio_connector.fft_data.connect(self.mixer.audio.update_fft_data)
self.aubio_connector.pitch_data.connect(self.mixer.audio.update_pitch_data)
self.aubio_connector.moveToThread(self.aubio_thread)
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
def run(self):
self._running = True
self.mixer.run()
def stop(self):
self._running = False
self.aubio_thread.quit()
self.mixer.stop()
self.playlist.save()
self.settings["last-preset"] = self.playlist.active_preset.name()
self.settings.save()
def __init__(self,app,onlyDBAccess=False):
'''main window init'''
QtGui.QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.db = DB(self)
self.settings=Settings(self)
self.onlyDBAccess=onlyDBAccess
if onlyDBAccess:
return
#GUI setting
guiSettings(self)
connectSignals(self)
changeStyle(self)
self.taskOpened = False
self.app = app
loadContexts(self)
self.currentContext = self.settings.getInitContext()
selectCurrentContext(self)
self.loadTasksList(init=True)
self.tray=Trayicon(self)
self.timer=TaskReminder(self)
self.shortcuts=ShortcutsHandler(self,self.settings['keyMainWindowToggle'])
finalizeInit(self)
self.translate()
self.adjustHeight(init=True)
def __init__(self, args=None):
super(MainFrame, self).__init__()
# Загружаем элементы окна
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Восстанавливаем состояние окна
self.settings = QtCore.QSettings(company_section, app_section)
self.restoreGeometry(self.settings.value("geometry"))
self.restoreState(self.settings.value("windowState"))
# Настройки
self.s = Settings()
self.s.saveEnv()
# Добавляем свой виджет
verticalLayout = QtGui.QVBoxLayout(self.ui.widget)
verticalLayout.setContentsMargins(0, 0, 0, 0)
self.ui.gragWidget = DragWidget(self.ui.widget, self.settings, self.s)
self.ui.gragWidget.setObjectName("gragWidget")
verticalLayout.addWidget(self.ui.gragWidget)
# Читаем из директории с базой данных данные о задачах
self.loadScheme()
def __init__(self, parent, args):
QtCore.QThread.__init__(self, parent)
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.qt_app = parent
self.scene.warmup()
self.aubio_connector = None
if not self.args.noaudio:
self.aubio_thread = QtCore.QThread()
self.aubio_thread.start()
self.aubio_connector = AubioConnector()
self.aubio_connector.onset_detected.connect(self.mixer.onset_detected)
self.aubio_connector.fft_data.connect(self.mixer.audio.update_fft_data)
self.aubio_connector.pitch_data.connect(self.mixer.audio.update_pitch_data)
self.aubio_connector.moveToThread(self.aubio_thread)
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
def onLoadFile(self):
initialdir = os.path.expanduser("~")
filename = askopenfilename(
initialdir=initialdir, filetypes=[("Config files", "*.pickle"), ("All files", "*.*")]
)
if filename:
self.s = Settings(filename=filename)
self.showInfo()
def onLoadFile(self):
initialdir = os.path.expanduser("~")
filename = askopenfilename(initialdir=initialdir, filetypes=[
('Config files', '*.pickle'),
('All files', '*.*'),
])
if filename:
self.s = Settings(filename=filename)
self.showInfo()
def test_parent(self):
"Fetches values from parent."
parent = Settings()
child = Settings(parent)
parent.a = 1
parent.b = 2
child.b = "overriden"
self.assertEqual(child.a, 1)
self.assertEqual(child.b, "overriden")
def __init__(self, parent, args):
QtCore.QThread.__init__(self, parent)
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.qt_app = parent
self.gui = None
self.scene.warmup()
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
class FireMixApp(QtCore.QThread):
"""
Main logic of FireMix. Operates the mixer tick loop.
"""
playlist_changed = QtCore.Signal()
def __init__(self, args, parent=None):
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.aubio_connector = None
if self.args.audio:
self.aubio_connector = AubioConnector()
self.aubio_connector.onset_detected.connect(self.mixer.onset_detected)
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
QtCore.QThread.__init__(self, parent)
def run(self):
self._running = True
self.mixer.run()
def stop(self):
self._running = False
self.mixer.stop()
self.playlist.save()
self.settings.save()
self.scene.save()
def __init__(self, args, parent=None):
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
self.scene = Scene(SceneLoader(self))
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.aubio_connector = None
if self.args.audio:
self.aubio_connector = AubioConnector()
self.aubio_connector.onset_detected.connect(self.mixer.onset_detected)
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
QtCore.QThread.__init__(self, parent)
class FireMixApp(QtCore.QThread):
"""
Main logic of FireMix. Operates the mixer tick loop.
"""
playlist_changed = QtCore.Signal()
def __init__(self, args, parent=None):
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
self.scene = Scene(SceneLoader(self))
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.aubio_connector = None
if self.args.audio:
self.aubio_connector = AubioConnector()
self.aubio_connector.onset_detected.connect(self.mixer.onset_detected)
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
QtCore.QThread.__init__(self, parent)
def run(self):
self._running = True
self.mixer.run()
def stop(self):
self._running = False
self.mixer.stop()
self.playlist.save()
self.settings.save()
class FireMixApp(QtCore.QThread):
"""
Main logic of FireMix. Operates the mixer tick loop.
"""
playlist_changed = QtCore.pyqtSignal()
def __init__(self, parent, args):
QtCore.QThread.__init__(self, parent)
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.qt_app = parent
self.gui = None
self.scene.warmup()
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
def run(self):
self._running = True
self.mixer.start()
def stop(self):
self._running = False
self.mixer.stop()
self.playlist.save()
self.settings.save()
class FireMixApp(QtCore.QThread):
"""
Main logic of FireMix. Operates the mixer tick loop.
"""
playlist_changed = QtCore.pyqtSignal()
def __init__(self, parent, args):
QtCore.QThread.__init__(self, parent)
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.qt_app = parent
self.gui = None
self.scene.warmup()
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
def run(self):
self._running = True
self.mixer.start()
def stop(self):
self._running = False
self.mixer.stop()
self.playlist.save()
self.settings.save()
def test_default_injection(self):
self.assertEqual(
Settings._inject_defaults({}, None),
{})
self.assertEqual(
Settings._inject_defaults({}, {'foo': 'foov'}),
{'foo': 'foov'})
self.assertEqual(
Settings._inject_defaults({'foo': 'bar'}, {'foo': 'foov'}),
{'foo': 'bar'})
self.assertEqual(
Settings._inject_defaults({'foo': None}, {'foo': 'foov'}),
{'foo': 'foov'})
self.assertEqual(
Settings._inject_defaults(
{'foo':'foov','bar':None},
{'foo':'foo_default','bar':'bar_default','baz':'baz_default'}),
{'foo':'foov','bar':'bar_default','baz':'baz_default'}
)
self.assertEqual(
Settings._inject_defaults({'foo':{}}, {'foo':{'bar':'baz'}}),
{'foo':{'bar':'baz'}}
)
self.assertEqual(
Settings._inject_defaults({'foo':{'bar':'barv'}}, {'foo':{'bar':'barv','baz':'bazv'}}),
{'foo':{'bar':'barv','baz':'bazv'}}
)
s = Settings({}, {'foo': [1, 0], 'bar': ['barval', 'barval2']}, {'foo': 0, 'bar': 'barval'})
self.assertEqual(s['bar'], 'barval')
self.assertEqual(s['foo'], 0)
with self.assertRaises(InvalidSettingError):
Settings({}, {'foo': [1, 0], 'bar': ['barval', 'barval2']}, {'bar': 'barval'})
s = Settings({'bar': 'barval', 'foo': 1}, {'foo': [1, 0], 'bar': ['barval', 'barval2']}, {'bar': 2})
def send(to: str, subject: str, body: str):
host, port, user, password = Settings.get_smtp_data()
msg = MIMEMultipart('alternative')
msg['Subject'] = subject
msg['From'] = user
msg['To'] = to
msg.attach(MIMEText(body, 'html'))
server = smtplib.SMTP_SSL(host, port)
server.ehlo()
server.login(user, password)
server.sendmail(user, to, msg.as_string())
server.close()
def __setup(self):
flow = flow_from_clientsecrets(Settings.getSecret(),
message=self.MISSING_CLIENT_SECRETS_MESSAGE,
scope=self.YOUTUBE_READ_WRITE_SCOPE)
storage = Storage("%s-oauth2.json" % sys.argv[0])
credentials = storage.get()
if credentials is None or credentials.invalid:
flags = get_cmd_line_parser().parse_args()
credentials = run_flow(flow, storage, flags)
self.yt = build(self.YOUTUBE_API_SERVICE_NAME,
self.YOUTUBE_API_VERSION,
http=credentials.authorize(httplib2.Http()))
return self.yt
def test_as_dict(self):
"The ``as_dict`` method returns a dictionary of values."
x = Settings()
x.a = lambda s: s.init + " original"
x.a = lambda s: s.a + " and derived"
x.init = "init"
self.assertEqual(x.as_dict(), {
"a": "init original and derived",
"init": "init",
})
def __init__(self, parent, args):
QtCore.QThread.__init__(self, parent)
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
self.playlist = Playlist(self)
self.qt_app = parent
self.gui = None
self.scene.warmup()
self.mixer.set_playlist(self.playlist)
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
class Workload(QtGui.QMainWindow):
def __init__(self,app,onlyDBAccess=False):
'''main window init'''
QtGui.QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.db = DB(self)
self.settings=Settings(self)
self.onlyDBAccess=onlyDBAccess
if onlyDBAccess:
return
#GUI setting
guiSettings(self)
connectSignals(self)
changeStyle(self)
self.taskOpened = False
self.app = app
loadContexts(self)
self.currentContext = self.settings.getInitContext()
selectCurrentContext(self)
self.loadTasksList(init=True)
self.tray=Trayicon(self)
self.timer=TaskReminder(self)
self.shortcuts=ShortcutsHandler(self,self.settings['keyMainWindowToggle'])
finalizeInit(self)
self.translate()
self.adjustHeight(init=True)
def resizeEvent(self,e):
path=QtGui.QPainterPath()
rect=e.size()
path.addRoundedRect(-1,-1,rect.width()+1,rect.height()+1,7,7)
region=QtGui.QRegion(path.toFillPolygon().toPolygon())
self.setMask(region)
def taskListFocusIn(self,e):
if e.reason()==QtCore.Qt.FocusReason.TabFocusReason:
try:
item=self.ui.taskList.itemAt(0)
self.ui.taskList.setCurrentItem(self.ui.taskList.itemAt(0))
except:
pass
def toggle(self):
if self.isVisible():
self.hide()
else:
self.show()
def dropTask(self,e):
Task.dropTask(self, e)
def resizeColumns(self):
self.ui.taskList.setColumnWidth(0, 20)
self.ui.taskList.setColumnWidth(1, 20)
self.ui.taskList.hideColumn(0)
def setMarker(self,tasks):
icon=QtGui.QIcon(':res/status/clock.png')
items=self.ui.taskList.findItems("",QtCore.Qt.MatchContains|QtCore.Qt.MatchRecursive)
for i in items:
removeicon=QtGui.QIcon()
i.setIcon(2,removeicon)
for i in tasks:
for j in items:
if j.data(0,32)==i:
j.setIcon(2,icon)
def drawRow(self,painter,myopt,index):
myopt.decorationPosition=QtGui.QStyleOptionViewItem.Right
myopt.decorationAlignment=QtCore.Qt.AlignCenter
QtGui.QTreeWidget.drawRow(self.ui.taskList,painter,myopt,index)
# TASKS RELATED ACTIONS
def addTask(self):
t = self.ui.taskInput.text().strip()
if t =="":
return False
self.ui.taskInput.clear()
priority = 0
try:
if t[1] == ":":
priority = int(t[0])
if priority<6:
t = t[2:]
else:
priority = 0
elif t[-2] == ":":
priority = int(t[-1])
if priority<6:
t = t[:-2]
else:
priority = 0
except:
pass
#TODO: create new function to handle input (regexp etc)
if len(t)>50:
taskname=t[:50]
taskDescription=t
else:
taskname=t
taskDescription=""
if self.checkIfExist(taskname) is not True:
duedate=self.defaultDueDate()
taskid = self.db.addTask(taskname,priority, taskDescription, duedate, self.currentContext)
self.createTaskItem(taskname, taskid, priority)
self.adjustHeight()
self.ui.statusbar.showMessage(QtGui.QApplication.translate("ui","New task created."),3300)
else:
self.ui.taskInput.setText(taskname)
self.taskAlreadyExistMsg()
def defaultDueDate(self):
if self.settings["defaultDueDateOn"]:
dueValue=int(self.settings["defaultDueDateValue"])
if self.settings["defaultDueDateUnit"]=="0":
td=datetime.timedelta(hours=dueValue)
else:
td=datetime.timedelta(days=dueValue)
return timestamp(datetime.datetime.now()+td)
else:
return None
def createTaskItem(self, t, taskid=None, priority=0):
item = QtGui.QTreeWidgetItem([str(priority),"", t])
item.setData(0, 32, taskid)
item.setSizeHint(1, QtCore.QSize(0, 22))
self.ui.taskList.addTopLevelItem(item)
self.setPriorityColor(item, priority)
self.ui.taskList.sortItems(0,QtCore.Qt.AscendingOrder)
def checkIfExist(self,t):
if len(self.ui.taskList.findItems(t,QtCore.Qt.MatchFlags(QtCore.Qt.MatchExactly),2))>0:
return True
def taskAlreadyExistMsg(self,parent=None):
text=QtGui.QApplication.translate("ui","Task with same name already exist, choose another")
windowtitle=QtGui.QApplication.translate("ui","Task name already exists")
msgWindow=QtGui.QMessageBox()
if parent is not None: self=parent
msgWindow.information(self, windowtitle, text, buttons=QtGui.QMessageBox.Ok )
def loadTasksList(self, archived=False,init=False):
self.ui.taskList.clear()
for i in self.db.getTasks(self.currentContext):
self.createTaskItem(i[1], i[0],i[2])
def deleteSelectedTasks(self, force=False):
selectedItems = self.ui.taskList.selectedItems()
if len(selectedItems)>0:
tasks = []
for item in selectedItems:
tasks.append(item)
windowtitle=QtGui.QApplication.translate("ui","Delete task")
text=QtGui.QApplication.translate("ui","Do you really want to delete selected task(s) ?")
if force:
self.deleteTasks(tasks)
windowtitle=QtGui.QApplication.translate("ui","Delete task")
text=QtGui.QApplication.translate("ui","Do you really want to delete selected task(s) ?")
elif self.questionPopup(windowtitle,text):
self.deleteTasks(tasks)
self.adjustHeight(downSize=True)
def deleteTasks(self, tasks):
for item in tasks:
self.db.deleteTask(item.data(0, 32))
index = self.ui.taskList.indexOfTopLevelItem(item)
self.ui.taskList.takeTopLevelItem(index)
self.ui.statusbar.showMessage(QtGui.QApplication.translate("ui","Task removed."),3300)
def setTaskPriority(self,priority):
selectedItems = self.ui.taskList.selectedItems()
for item in selectedItems:
self.db.setTaskPriority(item.data(0, 32),priority)
self.setPriorityColor(item, priority)
item.setText(0,str(priority))
self.ui.taskList.sortItems(0,QtCore.Qt.AscendingOrder)
self.ui.statusbar.showMessage(QtGui.QApplication.translate("ui","Priority updated."),3300)
def setPriorityColor(self,item,priority):
icon=QtGui.QIcon(':res/status/'+str(priority)+'.png')
item.setIcon(1,icon)
def openTask(self,taskname=None):
if not self.taskOpened:
item = self.getSelectedItem()
if item:
Task(self,item.data(0, 32))
def getSelectedItem(self):
selectedItems = self.ui.taskList.selectedItems()
if len(selectedItems) == 1:
item = self.ui.taskList.selectedItems()[0]
return item
else:
return False
# SHORTCUTS AND KEYBOARD EVENTS RELATED ACTIONS
def getKeysOnList(self, e):
if e.key() == 16777223: # delete
if (QtCore.Qt.ShiftModifier & e.modifiers()):
self.deleteSelectedTasks(True)
elif e.key()>48 and e.key()<54:
self.setTaskPriority(e.key()-48)
elif e.key()==78:
self.ui.taskInput.setFocus()
else:
QtGui.QTreeWidget.keyPressEvent(self.ui.taskList,e)
def getKeysOnInput(self, e):
if e.key()==16777221 or e.key()==16777220: # enter/return
if (QtCore.Qt.AltModifier & e.modifiers()):
self.createTask()
else:
self.addTask()
else:
QtGui.QLineEdit.keyPressEvent(self.ui.taskInput,e)
input=self.ui.taskInput.text()
if len(input)>50:
taskname=input[:50].strip()
taskname=taskname.replace("\r\n","\n")
taskname=taskname.replace("\n"," ")
taskname=taskname.replace("\t"," ")
taskname=taskname.replace(" ","")
description=input
Task(self,taskid=0,taskname=taskname,description=description)
self.ui.taskInput.clear()
#ADDITIONAL FUNTIONS
def questionPopup(self, title, msg):
window=QtGui.QMessageBox()
window.setWindowFlags(QtCore.Qt.FramelessWindowHint)
resp = window.question(self, title, msg,
buttons=QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel)
if resp == QtGui.QMessageBox.Ok:
return True
else:
return False
#WINDOWS MOVEMENT
def mouseMoveEvent(self, e):
if e.buttons() & QtCore.Qt.LeftButton:
try:
self.posx
self.posy
except:
self.posx=e.x()
self.posy=e.y()
y=e.globalY()-self.posy
x=e.globalX()-self.posx
self.move(x,y)
#e.accept()
def mouseReleaseEvent(self, e):
try:
del(self.posx)
del(self.posy)
except:
pass
def adjustHeight(self,downSize=False,init=False):
tasks=self.db.getTasks(self.currentContext)
if len(tasks)>0:
item=self.ui.taskList.topLevelItem(0)
qmodel=self.ui.taskList.indexFromItem(item)
taskheight=self.ui.taskList.rowHeight(qmodel)
else:
taskheight=22
if init:
winheight=320
listheight=252
else:
winheight=self.height()
listheight=self.ui.taskList.height()
desiredHeight=taskheight*len(tasks)+winheight-listheight+6
if ( desiredHeight>self.height() or downSize ) and desiredHeight<QtGui.QApplication.desktop().height():
self.resize(self.width(),desiredHeight)
def closeEvent(self, e=None):
self.hide()
if e:
e.ignore()
###### MENU FUNCTIONS
def importTasklist(self):
fname=QtGui.QFileDialog.getOpenFileName(self, QtGui.QApplication.translate("ui","Open"), "", QtGui.QApplication.translate("ui","Workload Import File (*.w)"))
if fname[0]:
filename=fname[0]
from lib import importexport
importexport.importTasks(self,filename,self.settings["dateFormat"])
def exportTaskList(self):
fname=QtGui.QFileDialog.getSaveFileName(self,QtGui.QApplication.translate("ui","Save"), "", QtGui.QApplication.translate("ui","Workload Export File (*.w)"))
if fname[0]:
includeArchive=self.questionPopup(QtGui.QApplication.translate("ui","Exporting tasks"), QtGui.QApplication.translate("ui","Do you want to include completed tasks?"))
tasks=self.db.exportTasks(self.currentContext, includeArchive)
from lib import importexport
filename=fname[0]
importexport.export(tasks, filename,self.settings["dateFormat"])
def about(self):
f=open("about.html")
text=f.read()
f.close()
QtGui.QMessageBox.information(self, QtGui.QApplication.translate("ui","About"), text, buttons=QtGui.QMessageBox.Ok )
def exit(self,exitcode=0):
exit_=False
if self.settings["askOnExit"]:
if self.questionPopup(QtGui.QApplication.translate("ui","Exit"), QtGui.QApplication.translate("ui","Are you sure?")):
exit_=True
else: exit_=True
if exit_==True:
self.settings.setCurrentContextAsLast()
self.shortcuts.terminate()
self.app.exit(exitcode)
def createTask(self):
Task(self,taskid=0)
def completeTasks(self):
if self.ui.taskList.hasFocus():
tasks=self.ui.taskList.selectedItems()
for i in tasks:
self.db.completeTask(i.data(0,32))
index = self.ui.taskList.indexOfTopLevelItem(i)
self.ui.taskList.takeTopLevelItem(index)
self.ui.statusbar.showMessage(QtGui.QApplication.translate("ui","Task completed."),3300)
def showHistory(self):
ArchiveWindow(self)
def hoyKeyError(self):
QtGui.QMessageBox.critical(self,QtGui.QApplication.translate("ui","Error"),QtGui.QApplication.translate("ui","Unable to register global shortcut"))
def changeEvent(self, e):
if e.type()==QtCore.QEvent.LanguageChange:
self.ui.retranslateUi(self)
self.ui.statusbar.showMessage(QtGui.QApplication.translate("ui","Hello! Ready to work ;-)"),3600)
loadContexts(self)
selectCurrentContext(self)
QtGui.QMainWindow.changeEvent(self,e)
def translate(self,lang=None):
if lang is None:
lang= self.settings["lang"]
translate=True
if lang=="auto":
locale = QtCore.QLocale.system().name()
elif lang=="en":
translate=False
try:
self.app.removeTranslator(self.qtTranslator)
except:
pass
else:
locale=lang
if translate:
self.qtTranslator = QtCore.QTranslator()
self.qtTranslator.load("i18n"+os.sep+"workload_"+locale+".qm")
self.app.installTranslator(self.qtTranslator)
def showMsg(self,msg):
msgWindow=QtGui.QMessageBox()
msgWindow.information(self, "Workload - Information", msg, buttons=QtGui.QMessageBox.Ok )
def test_is_in_dict(self):
self.assertTrue(Settings._is_in_dict({'a':'b','c':'d'}, {'c':['d'],'a':['b']}))
self.assertFalse(Settings._is_in_dict({'a':'b'}, {'c':['d'],'a':['c']}))
self.assertTrue(Settings._is_in_dict({'d':'f','a':['b','c']}, {'d':['e','f'],'a':['x','c','g','b','h']}))
self.assertTrue(Settings._is_in_dict({'d':'e','a':['b','c']}, {'d':['e','f'],'a':['x','c','g','b','h']}))
self.assertFalse(Settings._is_in_dict({'d':'f','a':['b','c']}, {'d':['e','f'],'a':['x','c','g','i','h']}))
self.assertTrue(Settings._is_in_dict({'a':{'b':'c','f':'g'},'d':'e'}, {'d':['e'],'a':{'f':['g'],'b':['h','c']}}))
self.assertFalse(Settings._is_in_dict({'a':{'b':'c','f':'g'},'d':'e'}, {'d':['e'],'a':{'f':['g'],'b':['h','i']}}))
self.assertTrue(Settings._is_in_dict(
{'a': ['b', ['c']], 'd': 'f'},
{'d': ['e', 'f'], 'a': ['x', ['c', 'g'], 'b', 'h']}))
self.assertFalse(Settings._is_in_dict(
{'a': ['b', ['c']]},
{'d': ['e', 'f'], 'a': ['x', 'c', ['g', 'i'], 'h', 'b']}))
self.assertFalse(Settings._is_in_dict(
{'a': ['b', ['c']]},
{'d': ['e', 'f'], 'a': ['x', ['c', 'g', 'i'], 'h']}))
self.assertTrue(Settings._is_in_dict(
{'a':[{'b':'c'}]},
{'a':[{'d','e'},{'b':'c'}]}
))
self.assertTrue(Settings._is_in_dict(
{'a': {'b':'c'}},
{'a': [{'b':'c'}]}
))
def test_is_in_list(self):
self.assertTrue(Settings._is_in_list(['x','y'], ['a','y','c','x']))
self.assertTrue(Settings._is_in_list([['x']], [['z'], ['x','y']]))
self.assertTrue(Settings._is_in_list([['x']], [['z'], ['x','a']]))
self.assertFalse(Settings._is_in_list([['x']], [['z'], ['b','a']]))
self.assertTrue(Settings._is_in_list([['x']], [['z'], ['b','a'], ['y','x']]))
self.assertTrue(Settings._is_in_list([['y']], [['z'], ['b','a'], ['y','x']]))
self.assertFalse(Settings._is_in_list([['c']], [['z'], ['b','a'], ['y','x']]))
self.assertFalse(Settings._is_in_list([['c','x']], [['z'], ['b','a'], ['y','x']]))
self.assertFalse(Settings._is_in_list([['c','x']], [['z'], ['b','c','a'], ['y','x']]))
self.assertTrue(Settings._is_in_list([['c','x']], [['z'], ['b','c','a'], ['y','x','z','c','f']]))
self.assertTrue(Settings._is_in_list([['c','x','z']], [['z'], ['b','c','a'], ['y','x','z','c','f']]))
self.assertFalse(Settings._is_in_list([['c','x','b']], [['z'], ['b','c','a'], ['y','x','z','c','f']]))
self.assertTrue(Settings._is_in_list([[[[['a'], ['y']]]]], [[[[['a', 'b', 'c', 'y', 'z']]]]]))
self.assertFalse(Settings._is_in_list([[[['a'], ['y']]]], [[[[['a', 'b', 'c', 'y', 'z']]]]]))
self.assertTrue(Settings._is_in_list([[[[['a','c'], ['y']]]]], [[[[['y', 'z'], ['a', 'b', 'c']]]]]))
self.assertFalse(Settings._is_in_list([[[['a','c'], ['y']]]], [[[[['y','z'],['a', 'b', 'c']]]]]))
self.assertFalse(Settings._is_in_list([[[[['a','y'], ['c']]]]], [[[[['y', 'z'], ['a', 'b', 'c']]]]]))
def test_is_in_prim(self):
self.assertTrue(Settings._is_in_prim('z', ['x', 'y', 'z']))
self.assertTrue(Settings._is_in_prim('x', ['x', 'y', 'z']))
self.assertTrue(Settings._is_in_prim('y', ['x', 'y', 'z']))
self.assertFalse(Settings._is_in_prim('a', ['x', 'y', 'z']))
def test_ctor(self):
Settings({'foo': 0}, {'foo': [0, 1]})
Settings({'foo': 1}, {'foo': [0, 1]})
Settings({'foo': 0, 'bar': 'barval'},
{'foo': [0, 1], 'bar': ['barval', 'barval2']})
Settings({'foo': 0, 'bar': 'barval2'},
{'foo': [0, 1], 'bar': ['barval', 'barval2']})
with self.assertRaises(InvalidSettingError):
Settings({'foo': 1}, {'foo': [0, 2]})
with self.assertRaises(InvalidSettingError):
Settings({'foo': 0, 'bar': 'barval'},
{'foo': [0, 1], 'bar': ['barval1', 'barval2']})
with self.assertRaises(InvalidSettingError):
Settings({'foo': 0, 'bar': 'barr'}, {'foo': [1, 0], 'bar': []})
Settings({'foo':['a','b']}, {'foo':['a','b','c','d']})
Settings({'foo':[['a','b']]}, {'foo':[['c','d'],['b','a']]})
Settings({'foo':[['a']]}, {'foo':[['c','d'],['a','b']]})
Settings({'foo':[['b']]}, {'foo':[['c','d'],['a','b']]})
Settings({'foo':[['b'], ['a']]}, {'foo':[['c','d'],['a','b']]})
Settings({'foo':[['b'], ['d']]}, {'foo':[['c','d'],['a','b']]})
Settings({'foo':[['b'], []]}, {'foo':[['c','d'],['a','b']]})
Settings({'foo':{'bar':'a'}}, {'foo':{'bar':['b','a']}})
Settings({'foo':{'bar':'a'}}, {'foo':[{'baz':['c','d']},{'bar':['b','a']}]})
with self.assertRaises(InvalidSettingError):
Settings({'foo':{'bar':'a'}}, {'foo':[{'baz':['c','d']},{'bar':['b','a'],'mu':['e','f']}]})
Settings({'foo':{'bar':'a','mu':'e'}}, {'foo':[{'baz':['c','d']},{'bar':['b','a'],'mu':['e','f']}]})
Settings({'foo':{'baz':'d'}}, {'foo':[{'baz':['c','d']},{'bar':['b','a'],'mu':['e','f']}]})
with self.assertRaises(InvalidSettingError):
Settings({'foo':[['b','d']]}, {'foo':[['c','d'],['b','a']]})
Settings(
{'foo': [{'bar': 3}, {'baz': 4}]},
{'foo': [
{'bar': [4, 3]},
{'baz': [4, 5]},
{'mu': [6, 7]}
]})
Settings(
{'foo': {'bar': 'baz'}},
{'foo': [{'bar': ['mu', 'baz']}]})
def test_is_in_prim_order(self):
Settings._validity_check({'foo':'foov'},{'foo':['foov','*:bool',r'\d+:re']})
Settings._validity_check({'foo':True},{'foo':['foov','*:bool',r'\d+:re']})
Settings._validity_check({'foo':3},{'foo':['foov','*:bool',r'\d+:re']})
Settings._validity_check({'foo':'True'},{'foo':[r'True:re','*:bool']})
Settings._validity_check({'foo':False},{'foo':[r'True:re','*:bool']})
with self.assertRaises(InvalidSettingError):
Settings._validity_check({'foo':False},{'foo':[r'True:re']})
def test_is_regex_match(self):
self.assertTrue(Settings._is_regex_match('foo', r'\w+:re'))
self.assertTrue(Settings._is_regex_match('foo', r'F\w:re:I'))
self.assertFalse(Settings._is_regex_match('foo', r'F\w$:re:I'))
self.assertTrue(Settings._is_regex_match('foo', r'F\w+:re:I '))
with self.assertRaises(InvalidRegexError):
self.assertTrue(Settings._is_regex_match('foo', r'F\w+:re:I Z'))
with self.assertRaises(InvalidRegexError):
self.assertTrue(Settings._is_regex_match('foo', r'F\w+:re:i'))
self.assertFalse(Settings._is_regex_match("f\no", r'...:re'))
self.assertTrue(Settings._is_regex_match("f\no", r'...:re:S'))
self.assertFalse(Settings._is_regex_match("f\no", r'F..:re:S'))
self.assertFalse(Settings._is_regex_match("f\no", r'F..:re:I'))
self.assertTrue(Settings._is_regex_match("f\no", r'F..:re:IS'))
self.assertTrue(Settings._is_regex_match("f\no", r'F..:re:SI'))
with self.assertRaises(InvalidSettingError):
Settings._validity_check({'foo': 'bar'}, {'foo': r'B\w+:re'})
Settings._validity_check({'foo': 'bar'}, {'foo': r'B\w:re:I'})
Settings._validity_check({'foo': 'b\nr'}, {'foo': r'B.\w:re:IS'})
with self.assertRaises(InvalidSettingError):
Settings._validity_check({'foo': 'b\nr'}, {'foo': r'B.\w:re:I'})
Settings._validity_check({'foo':{'baz':'b\nr'}}, {'foo':{'baz':r'B.\w:re:IS'}})
Settings._validity_check({'foo':345}, {'foo':r'\d+:re'})
Settings._validity_check({'foo':True}, {'foo':r'True:re'})
Settings._validity_check({'foo':False}, {'foo':r'False:re'})
Settings._validity_check({'foo':3.4}, {'foo':r'\d+(\.\d+)?:re'})
Settings._validity_check({'foo':34}, {'foo':r'\d+(\.\d+)?:re'})
import sys, threading, webbrowser
try:
from .lib.info import __pkgname__, __description__, __version__
from .lib.backwardcompat import *
from .lib.dump import plain
from .lib.settings import Settings
except:
from lib.info import __pkgname__, __description__, __version__
from lib.backwardcompat import *
from lib.dump import plain
from lib.settings import Settings
s = Settings()
s.saveEnv()
class ScrolledText(tk.Frame):
def __init__(self, parent=None):
tk.Frame.__init__(self, parent)
self.text = tk.Text(self, relief=tk.SUNKEN)
self.text.pack(fill=tk.BOTH, side=tk.LEFT, expand=tk.YES)
sbar = tk.Scrollbar(self)
sbar.pack(fill=tk.Y, side=tk.RIGHT)
sbar.config(command=self.text.yview)
self.text.config(yscrollcommand=sbar.set)
def test_wildcard_validity(self):
self.assertTrue(Settings._is_wildcard_match('foo', '*'))
self.assertTrue(Settings._is_wildcard_match(3, '*'))
self.assertTrue(Settings._is_wildcard_match(False, '*'))
self.assertTrue(Settings._is_wildcard_match(3.5, '*'))
self.assertTrue(Settings._is_wildcard_match('foo', '*:str'))
self.assertFalse(Settings._is_wildcard_match('foo', '*:bool'))
self.assertTrue(Settings._is_wildcard_match(True, '*:bool'))
self.assertFalse(Settings._is_wildcard_match(3, '*:bool'))
self.assertTrue(Settings._is_wildcard_match(3, '*:int'))
self.assertFalse(Settings._is_wildcard_match(3.5, '*:int'))
self.assertTrue(Settings._is_wildcard_match(3.5, '*:float'))
self.assertFalse(Settings._is_wildcard_match('foo', '*:float'))
with self.assertRaises(InvalidWildcardError):
Settings._is_wildcard_match(3.5, '*:foo')
self.assertTrue(Settings._is_in_prim('foo', '*'))
self.assertTrue(Settings._is_in_prim('foo', '*:str'))
self.assertFalse(Settings._is_in_prim('foo', '*:bool'))
Settings._validity_check({'foo':'bar'}, {'foo':'*'})
Settings._validity_check({'foo':'bar'}, {'foo':'*:str'})
with self.assertRaises(InvalidSettingError):
Settings._validity_check({'foo':'bar'}, {'foo':'*:bool'})
Settings._validity_check({'foo':'bar'}, {'foo':['*:int','*:str']})
def openSettings(self):
if self.settingsForm is None:
self.settingsForm = Settings(self)
self.settingsForm.show()
def onLoadDefault(self):
self.s = Settings()
self.showInfo()
def main():
conf = Settings(getcwd()+"/pool.json")
conf.run_async_checks()
BindServer(ip='10.20.30.53', resolver=conf.resolve)
class MainFrame(QtGui.QMainWindow):
def __init__(self, args=None):
super(MainFrame, self).__init__()
# Загружаем элементы окна
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Восстанавливаем состояние окна
self.settings = QtCore.QSettings(company_section, app_section)
self.restoreGeometry(self.settings.value("geometry"))
self.restoreState(self.settings.value("windowState"))
# Настройки
self.s = Settings()
self.s.saveEnv()
# Добавляем свой виджет
verticalLayout = QtGui.QVBoxLayout(self.ui.widget)
verticalLayout.setContentsMargins(0, 0, 0, 0)
self.ui.gragWidget = DragWidget(self.ui.widget, self.settings, self.s)
self.ui.gragWidget.setObjectName("gragWidget")
verticalLayout.addWidget(self.ui.gragWidget)
# Читаем из директории с базой данных данные о задачах
self.loadScheme()
# События
def OnAbout(self):
msg = u"{0}\n".format(__description__)
msg += u"Version: {0}\n\n".format(__version__)
msg += u"Author: Stan <*****@*****.**>\n"
msg += u"License: MIT\n\n"
msg += u"Python: {0}\n".format(sys.version)
msg += u"PySide: {0}\n".format(__version__)
msg += u"Qt: {0}\n".format(QtCore.__version__)
QtGui.QMessageBox.about(None, "About", msg)
def OnAbout_Qt(self):
QtGui.QApplication.aboutQt()
def closeEvent(self, event):
# Сохраняем состояние окна
self.settings.setValue("geometry", self.saveGeometry())
self.settings.setValue("windowState", self.saveState())
# Сохраняем данные о задачах
self.saveScheme()
event.accept()
# Основной функционал
def loadScheme(self):
tasks = self.s.get('tasks', [])
for task in tasks:
draw_task(self.ui.gragWidget, task)
def saveScheme(self):
tasks = []
for task in self.ui.gragWidget.tasks_list():
task_dict = {}
for key, value in task.items():
if isinstance(value, (simple_types, collections_types, dict)):
task_dict[key] = value
tasks.append(task_dict)
self.s.set('tasks', tasks)
# Сервисные функции
def set_status(self, message=''):
if isinstance(message, (list, tuple)):
message = u"{0} и др. значения".format(message[0])
self.sb_message = message
self.ui.statusbar.showMessage(self.sb_message)
class AppUI(tk.Tk):
def __init__(self):
tk.Tk.__init__(self)
self.title("tkSettings")
### Menu ###
self.menubar = tk.Menu(self)
menu = tk.Menu(self.menubar, tearoff=0)
self.menubar.add_cascade(label="File", menu=menu)
menu.add_command(command=self.onLoadDefault, label="Load default")
menu.add_command(command=self.onLoadFile, label="Load file")
menu.add_separator()
menu.add_command(command=self.quit, label="Exit")
menu = tk.Menu(self.menubar, tearoff=0)
self.menubar.add_cascade(label="Edit", menu=menu)
menu.add_command(command=self.onCleanData, label="Clean data")
menu = tk.Menu(self.menubar, tearoff=0)
self.menubar.add_cascade(label="Batch import", menu=menu)
menu.add_command(command=self.onBatch1, label="File to file")
menu = tk.Menu(self.menubar, tearoff=0)
self.menubar.add_cascade(label="Help", menu=menu)
menu.add_command(command=self.onAbout, label="About")
self.config(menu=self.menubar)
### Widgets ###
# Frame with Buttons
self.frame1 = tk.Frame(self)
button = tk.Button(self.frame1, text="Settings")
button.pack()
button.bind("<Button-1>", self.onShowSettings)
button = tk.Button(self.frame1, text="Save test data")
button.pack()
button.bind("<Button-1>", self.onSaveTestData)
button = tk.Button(self.frame1, text="Import from module")
button.pack()
button.bind("<Button-1>", self.onImportFromModule)
button = tk.Button(self.frame1, text="Import from module to branch")
button.pack()
button.bind("<Button-1>", self.onImportFromModuleToBranch)
button = tk.Button(self.frame1, text="Import from dir")
button.pack()
button.bind("<Button-1>", self.onImportFromDir)
button = tk.Button(self.frame1, text="Import from dir to branch")
button.pack()
button.bind("<Button-1>", self.onImportFromDirToBranch)
# Text Widget
dFont1 = Font(family="Courier", size=9)
self.text1 = tk.Text(self, font=dFont1)
self.text1_y = tk.Scrollbar(self, orient=tk.VERTICAL,
command=self.text1.yview)
self.text1['yscrollcommand'] = self.text1_y.set
# Status Widget
self.status = tk.StringVar()
label1 = tk.Label(self, textvariable=self.status, anchor=tk.W)
self.setStatus()
### Grid widgets ###
self.grid_rowconfigure(0, weight=1)
self.grid_columnconfigure(0, weight=1, minsize=120)
self.grid_columnconfigure(1, weight=5, minsize=400)
self.grid_columnconfigure(2)
self.frame1.grid(row=0, column=0, sticky='nwes')
self.text1.grid(row=0, column=1, sticky='nwes')
self.text1_y.grid(row=0, column=2, sticky='nwes')
self.grid_rowconfigure(1)
label1.grid(row=1, column=0, columnspan=4, sticky='nwes')
### Initial ###
self.onLoadDefault()
def appendText(self, text=""):
self.text1.insert(tk.INSERT, "{0}\n".format(plain(text)))
def setText(self, text=""):
self.text1.delete(1.0, tk.END)
self.appendText(text)
def setStatus(self, text=""):
status = sys.executable
if text:
status += " :: " + text
self.status.set(status)
def showInfo(self):
self.setText("System:")
self.appendText(self.s.get_systems())
self.appendText("Settings:")
self.appendText(self.s.get_dict())
self.setStatus(self.s.get_filename())
### From menu ###
def onAbout(self):
text = """{0}\n{1}\nVersion {2}\n
Python: {3}
Package: {4}
""".format(__pkgname__, __description__, __version__,
sys.version, __package__)
showinfo("About", text)
def onLoadDefault(self):
self.s = Settings()
self.showInfo()
def onLoadFile(self):
initialdir = os.path.expanduser("~")
filename = askopenfilename(initialdir=initialdir, filetypes=[
('Config files', '*.pickle'),
('All files', '*.*'),
])
if filename:
self.s = Settings(filename=filename)
self.showInfo()
def onCleanData(self):
response = askquestion("Clean data", "Are you sure you want to "
"permanently delete all information from the config?")
if response == 'yes':
self.s.clean()
self.showInfo()
def onBatch1(self):
dfilename = askdirectory()
if dfilename:
pickles = []
for filename in glob.glob(os.path.join(dfilename, '*.py')):
module = import_file(filename)
if module:
basename = os.path.basename(filename)
root, ext = os.path.splitext(basename)
logging.debug(root)
BRANCH = Settings(root)
pickles.append(BRANCH.get_filename())
for i in dir(module):
if i[0] != '_':
value = getattr(module, i)
if isinstance(value, all_types):
BRANCH.set(i, value)
message = "Processed pickles:\n" + plain(pickles) + "\n\n" +\
"Note: Empty pickles was not created!"
showinfo("Info", message)
self.setText()
self.setStatus()
### From buttons ###
def onShowSettings(self, event):
propertyDialog(self.s.get_dict())
def onSaveTestData(self, event):
self.s.saveEnv()
self.s.set_path('test_instance', '$')
self.s.set_path('test_home', '~')
self.s.set_path('test_location', '~~', True)
self.s.set_path('test_app', '~~~', True)
self.showInfo()
def onImportFromModuleToBranch(self, event):
self.onImportFromModule(event, tobranch=True)
def onImportFromModule(self, event, tobranch=False):
filename = askopenfilename(filetypes=[
('Python files', '*.py'),
('All files', '*.*'),
])
if filename:
module = import_file(filename)
if module:
if tobranch:
branch = module.__name__
BRANCH = self.s.get_group(branch)
else:
BRANCH = self.s
for i in dir(module):
if i[0] != '_':
value = getattr(module, i)
if isinstance(value, all_types):
BRANCH.set(i, value)
self.showInfo()
def onImportFromDirToBranch(self, event):
self.onImportFromDir(event, tobranch=True)
def onImportFromDir(self, event, tobranch=False):
dfilename = askdirectory()
if dfilename:
basename = os.path.basename(dfilename)
logging.debug(basename)
ROOT = self.s # Settings(basename)
for filename in glob.glob(os.path.join(dfilename, '*.py')):
module = import_file(filename)
if module:
if tobranch:
branch = module.__name__
BRANCH = self.s.get_group(branch)
else:
BRANCH = self.s
for i in dir(module):
if i[0] != '_':
value = getattr(module, i)
if isinstance(value, all_types):
BRANCH.set(i, value)
self.showInfo()
class WebinyNotifier(QtGui.QApplication, QObject):
processMonitorLog = ''
def __init__(self, args):
QtGui.QApplication.__init__(self, args)
QObject.__init__(self, args)
self.setQuitOnLastWindowClosed(False)
self.tray = Tray(parent=self)
self.settingsForm = None
self.logForm = None
self.settings = SettingsObj()
# Connect slot so Listener can forward request data to main thread
self.listener = Listener()
self.connect_slots(self.listener)
self.listener.start()
self.exec_()
def restartListener(self):
print "Restarting listener..."
self.listener.stop()
self.listener = Listener()
self.connect_slots(self.listener)
self.listener.start()
def connect_slots(self, sender):
self.connect(sender, QtCore.SIGNAL('newNotification'), self.newNotification)
def newNotification(self, params):
# Store new request
request = Request()
request.createFromNodeJs(params)
# Notification balloon
if bool(self.settings.show_balloon) and bool(self.settings.log_levels[request.getLevel()]['balloon']):
message = "[" + strftime("%Y-%m-%d %H:%M:%S", gmtime()) + "] New notification received!"
Debugger.log('Showing tray message: ' + message)
self.tray.showMessage('Webiny Notifier', message, QtGui.QSystemTrayIcon.Information, 10000000)
self.refreshRequestsModel()
def openSettings(self):
if self.settingsForm is None:
self.settingsForm = Settings(self)
self.settingsForm.show()
def openLog(self):
"""
if self.logForm is None:
self.logForm = Log()
self.logForm.show()
"""
def refreshRequestsModel(self):
if hasattr(self, "mainWindow"):
self.mainWindow.refreshRequestModel()
def exitApp(self):
del self.tray
self.listener.stop()
self.quit()
def balloonClicked(self):
Debugger.log('Balloon clicked')
if not hasattr(self, "mainWindow"):
self.mainWindow = MainWindow(self)
if not self.mainWindow.isVisible():
self.mainWindow.show()
if self.mainWindow.isMinimized():
self.mainWindow.showNormal()
self.mainWindow.activateWindow()
self.mainWindow.selectFirstRow()
def iconClicked(self, reason):
if reason == 2:
Debugger.log('Tray icon clicked')
if not hasattr(self, "mainWindow"):
self.mainWindow = MainWindow(self)
self.mainWindow.activateWindow()
if self.mainWindow.isVisible():
self.mainWindow.hide()
else:
self.mainWindow.show()
self.mainWindow.activateWindow()
def __init__(self, args, parent=None):
self._running = False
self.args = args
self.settings = Settings()
self.net = Networking(self)
BufferUtils.set_app(self)
self.scene = Scene(self)
self.plugins = PluginLoader()
self.mixer = Mixer(self)
# Create the default layer.
default_playlist = Playlist(self, self.args.playlist, 'last_playlist',
subdir = 'Music')
default_audiolist = Audiolist(self, self.args.audiobehaviors, 'last_audiolist',
subdir = 'Music')
default_layer = MusicLayer(self)
default_layer.set_playlist(default_playlist)
default_layer.set_audiolist(default_audiolist)
default_layer.setForeground()
self.mixer.add_layer(default_layer)
if self.args.speech_layer or self.args.all:
speech_playlist = Playlist(self, self.args.speech_playlist,
'last_speech_playlist', subdir = 'Speech')
speech_audiolist = Audiolist(self, self.args.speech_audiobehaviors,
'last_speech_audiolist', subdir = 'Speech')
speech_layer = SpeechLayer(self)
speech_layer.set_playlist(speech_playlist)
speech_layer.set_audiolist(speech_audiolist)
speech_layer.setBackground()
self.mixer.add_layer(speech_layer)
if self.args.leap_layer or self.args.all:
leap_playlist = Playlist(self, self.args.leap_playlist,
'last_leap_playlist', subdir = 'Leap')
leap_audiolist = Audiolist(self, self.args.leap_audiobehaviors,
'last_leap_audiolist', subdir = 'Leap')
leap_layer = LeapLayer(self)
leap_layer.set_playlist(leap_playlist)
leap_layer.set_audiolist(leap_audiolist)
leap_layer.setBackground()
self.mixer.add_layer(leap_layer)
self.scene.warmup()
self.aubio_connector = None
if not self.args.noaudio:
self.aubio_connector = AubioConnector()
self.aubio_connector.onset_detected.connect(self.mixer.onset_detected)
self.osc_server = None
if not self.args.noosc:
self.osc_server = OscServer(
self.args.osc_port, self.args.mixxx_osc_port, self.mixer)
self.osc_server.start()
if self.args.preset:
log.info("Setting constant preset %s" % args.preset)
self.mixer.set_constant_preset(args.preset)
QtCore.QThread.__init__(self, parent)
cycle_counter = 0
# Define stepper sequence
sequence = [
[1,0,0,0],
[1,1,0,0],
[0,1,0,0],
[0,1,1,0],
[0,0,1,0],
[0,0,1,1],
[0,0,0,1],
[1,0,0,1],
]
# Find best camera settings
settings = Settings()
auto_settings = settings.get_auto()
# Find closest allowed ISO
speed = auto_settings['iso']
speeds = [100, 200, 320, 400, 500, 640, 800]
iso = 800
minimum_diff = float('inf')
for value in speeds:
diff = abs(speed - value)
if diff <= minimum_diff:
minimum_diff = diff
iso = value
auto_settings['iso'] = iso
# Setup camera for capture
