def dist_daily_taw_run():
cfg2 = Config()
cfg2.load()
etrm2 = Processes(cfg2)
etrm2.set_save_dates(cfg2.save_dates)
etrm2.modify_taw(cfg2.taw_modification)
etrm2.run()
class TestConfig (unittest.TestCase):
""" Test Config class. """
def setUp(self):
""" Set up Config instance. """
config_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'config')
self.config = Config(config_dir)
def test_singleton_shared_state(self):
""" Check that two instances share state. """
second = Config()
second.foo = 'bar'
self.assertEqual('bar', self.config.foo)
self.config.bar = 'bash'
self.assertEqual('bash', second.bar)
def test_separate_tests(self):
""" Test that tests do not affect each other's copy of config. """
# Note, this relies on an implementation detail
self.assertNotIn('foo', self.config.__dict__)
def test_load(self):
""" Test loading a yaml config file. """
self.config.load('database')
self.assertIsNotNone(self.config.database)
def test_auto_load(self):
""" Test autoloading a yaml config file. """
self.assertIsNotNone(self.config.database)
class TestConfig(unittest.TestCase):
""" Test Config class. """
def setUp(self):
""" Set up Config instance. """
config_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'config')
self.config = Config(config_dir)
def test_singleton_shared_state(self):
""" Check that two instances share state. """
second = Config()
second.foo = 'bar'
self.assertEqual('bar', self.config.foo)
self.config.bar = 'bash'
self.assertEqual('bash', second.bar)
def test_separate_tests(self):
""" Test that tests do not affect each other's copy of config. """
# Note, this relies on an implementation detail
self.assertNotIn('foo', self.config.__dict__)
def test_load(self):
""" Test loading a yaml config file. """
self.config.load('database')
self.assertIsNotNone(self.config.database)
def test_auto_load(self):
""" Test autoloading a yaml config file. """
self.assertIsNotNone(self.config.database)
def dist_daily_taw_run():
cfg2 = Config()
cfg2.load()
etrm2 = Processes(cfg2)
etrm2.set_save_dates(cfg2.save_dates)
etrm2.modify_taw(cfg2.taw_modification)
etrm2.run()
def create_app():
app = Flask(__name__)
Config.load()
for repo_name in Config.repos:
repo = Repo(repo_name)
app.register_blueprint(repo.blueprint)
repos.append(repo)
if not os.path.exists(Config.path_repos):
os.makedirs(Config.path_repos, exist_ok=True)
return app
class Application:
def __init__(self, args):
Log.append('app_init', 'Info', 'version: %s' % Const.version)
set_default(default_zone=Zone(home_dir=pyinstaller.get_runtime_dir()))
self.qt = QApplication(args)
self.qt.setApplicationName(Const.app_name)
self.qt.setWindowIcon(
QIcon('%s/app/res/icon.png' % pyinstaller.get_runtime_dir()))
self.hook_exception()
self.config = Config()
self.config.load()
self.lang = None # type: English
self.load_language(Config.language)
self.events = {
'process_events': self.qt.processEvents,
'export_log': self.export_log,
'check_update': self.check_update,
'load_language': self.load_language,
'get_language': lambda: self.lang,
'set_language': self.set_language,
'get_config': lambda: self.config,
}
def load_language(self, language):
self.lang = load_language(language)
def set_language(self, language):
self.lang = load_language(language)
self.config.language = language
self.config.save()
def run(self):
init_app(events=self.events)
return self.qt.exec()
def callback_exception(self, exc=None):
if exc is None:
exc = common.get_exception()
Log.append(self.callback_exception, 'Error', exc)
if QMessageBox.warning(None, self.lang.title_crash,
self.lang.description_crash):
self.export_log()
def export_log(self):
folder = QFileDialog.getExistingDirectory(
None, caption=self.lang.menu_export_log)
if folder is not None:
log = Log.extract_log()
err = Log.extract_err()
for f in Config._protect_fields:
v = getattr(Config, f, '')
if v != '':
log = log.replace(v, Const.protector)
err = err.replace(v, Const.protector)
if log != '':
with open('%s/%s' % (folder, '%s.log' % Const.app_name),
'w') as io:
io.write(log)
if err != '':
with open('%s/%s' % (folder, '%s.err' % Const.app_name),
'w') as io:
io.write(err)
def check_update(self, test=False):
try:
release = github.get_latest_release(Const.author,
Const.app_name,
timeout=5)
Log.append(self.check_update, 'Info', release)
if test or common.compare_version(Const.version,
release['tag_name']):
if len(release['assets']) > 0:
QMessageBox.information(
self.lang.title_check_update, '%s\n%s\n\n%s' %
(self.lang.description_new_version, release['body'],
release['assets'][0]['browser_download_url']))
else:
QMessageBox.information(
self.lang.title_check_update, '%s\n%s\n\n%s' %
(self.lang.description_new_version, release['body'],
release['assets'][0]['browser_download_url']))
except:
Log.append(self.check_update, 'Warning', common.get_exception())
def hook_exception(self):
def boom(type, value, tb):
from io import StringIO
from app.util import io_helper
import traceback
with StringIO() as io:
traceback.print_exception(type, value, tb, file=io)
exc = io_helper.read_all(io)
self.callback_exception(exc)
sys.excepthook = boom
class MainWindow(BaseMainWindow, MainWindowView):
signal_set_preview = pyqtSignal(bytes)
signal_refresh_scene = pyqtSignal(list)
def __init__(self, app: BaseApplication):
self._config = Config()
self._config._config_path = os.path.expanduser('~/.coc_automator.json')
self._device = None # type: Device
self._event = dict(
config=lambda: self._config,
set_preview=lambda: self.signal_set_preview,
refresh_scenes=lambda: self.signal_refresh_scene,
)
super().__init__(app)
app_shell = get_app_shell()
self._adb = PyADB('%s/app/res/libs/adb' % app_shell.get_runtime_dir())
self._automator = COCAutomator(self._event)
self._automator.load('app/res/data.dat')
self.signal_set_preview.connect(self.set_preview)
self.signal_refresh_scene.connect(self.refresh_scenes)
if self._config.load():
devices = self._adb.devices
if len(devices) == 0:
self._adb.kill_server()
self._adb.start_server()
devices = self._adb.devices
self._device = devices.get(self._config.device)
self._automator.set_device(self._device)
def sync_scenes(self):
if self._device is not None:
scenes = self._project.scenes
data = []
for k, v in scenes.items():
v: SceneModel
data.append([k, len(v.accuracy)])
TableHelper.sync_data(self.tableWidgetScenes, data)
TableHelper.auto_inject_columns_width(self.tableWidgetScenes)
def _callback_select_device_triggered(self, b: bool):
devices = self._adb.devices
if len(devices) == 0:
self._adb.kill_server()
self._adb.start_server()
devices = self._adb.devices
item = SelectDialog.select(
self,
title=self.tr('Select Device'),
cols_title=[self.tr('Device'), self.tr('State')],
rows=[(sn, device.state) for sn, device in devices.items()],
item_keys=['sn', 'state'])
if item is not None:
self._device = devices[item['sn']]
self._automator.set_device(self._device)
self._config.device = item['sn']
self._config.save()
def _callback_settings_triggered(self, b: bool):
data = FormDialog.input([
StringField('device', self._config.device, self.tr('Device')),
SelectField('app_package', Const.dta_app_packages,
self._config.app_package, self.tr('App Package')),
])
if data is not None:
object_convert.dict_to_object(data, self._config, False)
self._config.save()
@try_exec(show=True, info_only=True)
def _callback_run_triggered(self, b: bool):
package = self._config.app_package
if package != '':
self._device.app.start_by_package(package)
else:
raise Exception(self.tr('App Package is empty!'))
def _callback_kill_triggered(self, b: bool):
package = self._config.app_package
if package != '':
self._device.app.force_stop(package)
def _callback_restart_triggered(self, b: bool):
self._callback_kill_triggered(b)
self._callback_run_triggered(b)
def _callback_play_triggered(self, b: bool):
self._automator.play()
def _callback_pause_triggered(self, b: bool):
self._automator.pause()
def _callback_stop_triggered(self, b: bool):
self._automator.stop()
def _callback_scale_changed(self, v: int):
self.refresh_preview_size()
def refresh_preview_size(self):
pixmap = self.labelPreview.pixmap()
if pixmap is not None:
size = pixmap.size()
scale = self.verticalSliderScale.value(
) / self.verticalSliderScale.maximum()
size.setWidth(int(size.width() * scale))
size.setHeight(int(size.height() * scale))
self.labelPreview.setMinimumSize(size)
self.labelPreview.setMaximumSize(size)
def set_preview(self, img_data: bytes):
pixmap = QPixmap()
pixmap.loadFromData(img_data)
self.labelPreview.setPixmap(pixmap)
self.refresh_preview_size()
def refresh_scenes(self, data):
mi = -1
mv = 0
for i, (k, v) in enumerate(data):
if v > mv:
mi, mv = i, v
data[i] = [k, '%.6f' % v]
TableHelper.sync_data(self.tableWidgetScenes, data)
TableHelper.auto_inject_columns_width(self.tableWidgetScenes)
self.tableWidgetScenes.selectRow(mi)
self.app.processEvents()
def closeEvent(self, *args):
self._automator.stop()
self._automator.destroy()
return super().closeEvent(*args)
