def _perform_actions(self):
for tl_id, statuses in self._tls.items():
remaining_time = (traci.trafficlight.getNextSwitch(tl_id) -
traci.simulation.getCurrentTime()) / 1000.0
msg = {
'tl_id': tl_id,
'remaining_time': remaining_time,
}
phase_index = traci.trafficlight.getPhase(tl_id)
if phase_index != self._tls[tl_id]['current_phase']:
self._tls[tl_id]['current_phase'] = phase_index
status = self._tls[tl_id].get(phase_index, None)
if status == 'many':
print('Many vehicles, increasing this TL state duration!')
delta_time = remaining_time * (Config().multipliers_many -
1.0)
elif status == 'few' and remaining_time >= 6:
print('Few vehicles, decreasing this TL state duration!')
delta_time = remaining_time * (Config().multipliers_few -
1.0)
elif status == 'none':
print('No vehicles, decreasing this TL state duration!')
delta_time = remaining_time * (Config().multipliers_none -
1.0)
else:
print(
'Regular number of vehicles, not changing anything...')
delta_time = 0.0
traci.trafficlight.setPhaseDuration(
tl_id, round(remaining_time + delta_time))
msg['delta_time'] = delta_time
Producer.publish(msg, Config().kafka_topic_tl_times)
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 test_send_wrong_alert_level(self):
config = Config(config_file='test_config.yml')
config.set_fake_api_call(True, 202)
ms = MessageSender(config)
ms.WAIT_FACTOR = 0.01
alert_level = 3
with self.assertRaises(KeyError):
# alert level 3 does not exist in our config
config.alert_text['level_%s' % alert_level]
text = 'strong rains coming'
responses = ms.send_alert(alert_level, text)
expected = {
'config_errors':
[(202, {
'src': '+41791234566',
'text':
'faloppia.opengis.ch - IT Problem, No alarm numbers set for level 2 alarms',
'dst': '+41791234568'
}),
(202, {
'src': '+41791234566',
'text':
'faloppia.opengis.ch - IT Problem, No alarm numbers or text set for level 3 alarms',
'dst': '+41791234568'
})],
'main': (202, {
'src': '+41791234566',
'text': 'faloppia.opengis.ch - ALLARME, strong rains coming',
'dst': '+41791234567<+41791234568'
})
}
print(responses)
self.assertDictEqual(responses, expected)
def __init__(self):
super(SettingsPage, self).__init__()
self.ui = Ui_SettingsPage()
self.ui.setupUi(self)
self.ui.information_label.setVisible(False)
self.ui.database_location_button.clicked.connect(
self.selectDatabaseLocation)
self.ui.freerdp_executable_button.clicked.connect(
self.selectFreerdpLocation)
self.ui.save_button.clicked.connect(self.saveSettings)
self.config = Config()
self.ui.database_location.setText(self.config.databaseLocation)
self.ui.freerdp_executable.setText(self.config.freerdpExecutable)
self.ui.freerdp_arguments.setText(self.config.freerdpArgs)
self.keyMenu = QMenu()
self.keyMenu.addAction('Set master password', self.setKeyPassword)
self.ui.master_key_button.setStyleSheet(
"QPushButton::menu-indicator {image: none;}")
self.ui.master_key_button.setMenu(self.keyMenu)
self.ui.logging_level.addItems(self.config.loggingLevels)
currentItem = self.ui.logging_level.findText(self.config.logLevel)
if currentItem != -1:
self.ui.logging_level.setCurrentIndex(currentItem)
def main(
input,
config_file,
debug,
):
"""
Main entry point for testing_oneclick_cli.
:param input: Something
:param config_file: Path to the yaml config file.
:param debug: Debug flag
:return Something
"""
if config_file:
with open(config_file, encoding='utf-8') as f:
config_contents = yaml.safe_load(f)
config = Config(**config_contents)
else:
config = Config()
print(input)
if debug:
with open('debug.yaml', 'w') as f:
yaml.dump(config.dict(), f)
def load_config(path: str) -> Config:
with open(path) as f:
dict_config = json.load(f)
config = Config()
config.fetch_from_dict(dict_config)
return config
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 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 test__fetch_selection_config_validData_fetchesValidVariables():
sel_config = {"method": "roulette", "agents_to_save": 1.0}
config = Config()
config._fetch_selection_config(sel_config)
assert config.selection_method == "roulette" and config.agents_to_save == 1.0
def test__fetch_mutation_config_emptyDict_returnsDefaultSettings():
mutation_config = {}
config = Config()
config._fetch_mutation_config(mutation_config)
assert config.mutation_method == "normalization" and config.mutation_rate == 0.0
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 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__fetch_mutation_config_validData_fetchesValidVariables():
mutation_config = {"method": "gene_creation", "rate": 0.1}
config = Config()
config._fetch_mutation_config(mutation_config)
assert config.mutation_method == "gene_creation" and config.mutation_rate == 0.1
def test__fetch_selection_config_emptyDict_returnsDefaultSettings():
sel_config = {}
config = Config()
config._fetch_selection_config(sel_config)
assert config.selection_method == "roulette" and config.agents_to_save == 0.0
def split(config: Config):
"""
Split the data into training and testing sets.
"""
if config.model_type == ModelType.automl:
logging.debug("Skipping because of model type")
return
data = pd.read_csv(config.path_to(PROCESSED_DATA_FILE_NAME))
if not config.hypertune:
testing_rate = 0.1 # 10% of data for testing
training_rate = 1 - testing_rate
logging.debug(f"Splitting into {training_rate * 100}% training, "
f"{testing_rate * 100}% testing")
train, test = np.split(data.sample(frac=1),
[int(training_rate * len(data))])
else: # Assume hypertuning
# We are hypertuning, so need both a validation and testing set
# 10% of data for testing, 10% for validation
testing_rate = 0.1
validation_rate = 0.1
training_rate = 1 - testing_rate - validation_rate
logging.debug(
f"Splitting into {training_rate * 100}% training, "
f"{testing_rate * 100}% testing, {validation_rate * 100}% validation"
)
train, validate, test = np.split(data.sample(frac=1), [
int(training_rate * len(data)),
int((training_rate + validation_rate) * len(data))
])
logging.info("Storing validation set as " +
config.path_to(VALIDATION_SET_FILE_NAME))
validate.to_csv(config.path_to(VALIDATION_SET_FILE_NAME),
encoding='utf-8',
index=False,
quoting=csv.QUOTE_NONE)
logging.info("Storing training set as " +
config.path_to(TRAINING_SET_FILE_NAME))
train.to_csv(config.path_to(TRAINING_SET_FILE_NAME),
encoding='utf-8',
index=False,
quoting=csv.QUOTE_NONE)
logging.info("Storing testing set as " + TESTING_SET_FILE_NAME)
test.to_csv(config.path_to(TESTING_SET_FILE_NAME),
encoding='utf-8',
index=False,
quoting=csv.QUOTE_NONE)
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 __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 write_config(self, **kwargs):
self.config.update(kwargs)
with open(os.path.join(self.config_dir.name, 'application.yaml'),
'w') as handler:
handler.write(yaml.dump(self.config, default_flow_style=False))
Config._full_reload()
def test_failed_send(self):
config = Config(config_file='test_config.yml')
config.set_fake_api_call(True, 400)
ms = MessageSender(config)
ms.WAIT_FACTOR = 0.01
with self.assertRaises(FatalError):
ms.send_alert(1, 'text')
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__fetch_crossover_config_emptyDict_returnsDefaultSettings():
cross_config = {}
config = Config()
config._fetch_crossover_config(cross_config)
assert (config.constant_length is True and config.initial_length == 0
and config.max_genes == 0)
def load_config(path: str) -> Config:
with open(f"{path}/config.json") as f:
dict_config = json.load(f)
config = Config()
config.fetch_from_dict(dict_config)
config.path_to_config = path
return config
def test__fetch_genes_config_emptyDict_returnsDefaultSettings():
genes_config = {}
config = Config()
config._fetch_genes_config(genes_config)
assert (config.fin_statement_lag == 135 and config.logic_to_all == 0.0
and config.fundamental_to_all == 0.0)
def get_connection(connection):
config = Config()
config = config.get_config()
if connection.__db is None:
connection.__db = connect(config['mongodb']['db'],
host=config['mongodb']['host'],
port=config['mongodb']['port'])
return connection.__db
def test(config: Config):
"""
Test a FastText model.
"""
if config.model_type == ModelType.automl:
logging.debug("Skipping because of model type")
return
model = load_model(config.path_to(MODEL_FILE_NAME))
logging.debug("Testing model")
logging.debug(f"{len(model.get_words())} words")
logging.debug(f"{len(model.get_labels())} labels")
samples, precision, recall = model.test(
config.path_to(TESTING_SET_FILE_NAME))
logging.info(f"Overall precision is {precision}")
logging.debug("Running detailed FastText testing")
label_results = model.test_label(config.path_to(TESTING_SET_FILE_NAME))
transformed_results = [[
label[9:], 0 if math.isnan(r["precision"]) else r["precision"],
r["recall"], r["f1score"]
] for label, r in label_results.items()]
tested_results = [
result for result in transformed_results if not math.isnan(result[3])
]
untested_labels = [
result[0] for result in transformed_results if math.isnan(result[3])
]
logging.debug(f"{len(untested_labels)} labels not present in test set")
test_df = pd.DataFrame(tested_results)
test_df.columns = ["label", "precision", "recall", "accuracy"]
test_df.sort_values(by="label", inplace=True)
logging.debug(
f"{len(test_df[test_df['accuracy'] == 0])} labels with no prediction hit"
)
means = test_df[test_df["accuracy"] != 0].mean()
logging.debug(
"Mean for labels with prediction (precision, recall, accuracy):")
logging.debug(means["precision"])
logging.debug(means["recall"])
logging.debug(means["accuracy"])
logging.info("Storing test results as " + TEST_RESULTS_FILE_NAME)
test_df.to_csv(config.path_to(TEST_RESULTS_FILE_NAME),
index=False,
sep=" ")
def controller():
cfg = Config()
pyinfo = sys.version
return render_template('index.html',
sitename=cfg.read_key('site', 'name'),
sitedesc=cfg.read_key('site', 'desc'),
siteport=cfg.read_key('server', 'port'),
pyinfo=pyinfo)
def test_configure_logging(self):
logging_config = None
if hasattr(Config, 'LOGGING_CONFIG'):
logging_config = Config.LOGGING_CONFIG
del Config.LOGGING_CONFIG
with self.assertRaises(RuntimeError):
Config.configure_logging()
if logging_config:
setattr(Config, 'LOGGING_CONFIG', logging_config)
def test__fetch_database_config_emptyDict_returnsDefaultSettings():
db_config = {}
config = Config()
config._fetch_database_config(db_config)
assert (config.min_circulation == 0 and config.max_circulation == 0
and config.sectors == [] and config.companies == []
and config.chunks == 0)
def create_app(config_name):
connexion_options = {"swagger_ui": True}
# This feels like a hack but it is needed. The logging configuration
# needs to be setup before the flask app is initialized.
configure_logging(config_name)
app_config = Config()
app_config.log_configuration(config_name)
connexion_app = connexion.App(
"inventory", specification_dir="./swagger/", options=connexion_options
)
# Read the swagger.yml file to configure the endpoints
with open("swagger/api.spec.yaml", "rb") as fp:
spec = yaml.safe_load(fp)
for api_url in app_config.api_urls:
if api_url:
connexion_app.add_api(
spec,
arguments={"title": "RestyResolver Example"},
resolver=RestyResolver("api"),
validate_responses=True,
strict_validation=True,
base_path=api_url,
)
app_config.logger.info("Listening on API: %s" % api_url)
# Add an error handler that will convert our top level exceptions
# into error responses
connexion_app.add_error_handler(InventoryException, render_exception)
flask_app = connexion_app.app
flask_app.config["SQLALCHEMY_ECHO"] = False
flask_app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
flask_app.config["SQLALCHEMY_DATABASE_URI"] = app_config.db_uri
flask_app.config["SQLALCHEMY_POOL_SIZE"] = app_config.db_pool_size
flask_app.config["SQLALCHEMY_POOL_TIMEOUT"] = app_config.db_pool_timeout
db.init_app(flask_app)
flask_app.register_blueprint(monitoring_blueprint,
url_prefix=app_config.mgmt_url_path_prefix)
@flask_app.before_request
def set_request_id():
threadctx.request_id = request.headers.get(
REQUEST_ID_HEADER,
UNKNOWN_REQUEST_ID_VALUE)
init_tasks(app_config, flask_app)
return flask_app
def main():
# Load config and get logger
cfg = Config()
logger = cfg.get_logger()
# Let's go
logger.info('Main:Session started')
lastfm = LastFmPipe(cfg)
lastfm.update_all()
logger.info('Main:Session closed')
def init(cls):
print("Initiating consumer...")
try:
cls.consumer = KafkaConsumer(bootstrap_servers=Config().kafka_endpoint,
value_deserializer=lambda m: json.loads(m.decode('utf-8')),
group_id=None,
consumer_timeout_ms=100)
cls.consumer.subscribe([Config().kafka_topic_tl_status])
except RuntimeError:
sys.exit(Fore.RED + "Connection to Kafka failed!" + Fore.RESET)
def test__fetch_wallet_config_emptyDict_returnsDefaultSettings():
wallet_config = {}
config = Config()
config._fetch_wallet_config(wallet_config)
assert (config.start_cash == 0 and config.return_method == "total_value"
and config.benchmark == "" and config.risk_free_return == 0.0
and config.fee_min == 0.0 and config.fee_rate == 0.0
and config.fee_added == 0.0 and config.fee_max == 0.0)
def __init__(self) -> None:
self.url = Config.get('URL_FETCHER', 'url')
try:
self.headers = Config.get('URL_FETCHER',
'headers',
param_type="json")
except JSONDecodeError:
Logger.get(self.__class__.__name__).warn(
"Problem decoding URL headers from JSON in config!")
self.headers = None
self.content: Optional[str] = None
def upgrade():
cryptoKey = Config().getPrivateKey()
connection = op.get_bind()
with connection.begin() as trans:
for host in connection.execute(hostsHelper.select().where(hostsHelper.c.password.isnot(None))):
try:
passwordToUpdate = cryptoKey.encrypt(host.password)
connection.execute(
hostsHelper.update().where(
hostsHelper.c.id == host.id
).values(password=passwordToUpdate)
)
except Exception as e:
logger.error(u"Error when trying to update host '{}'.".format(host.name))
raise e
def savePassword(self):
currentPassword = self.ui.currentPassword.text()
newPassword = self.ui.newPassword.text()
repeatNewPassword = self.ui.repeatPassword.text()
if self.isFieldEmpty(currentPassword) and self.isFieldEmpty(newPassword) and \
self.isFieldEmpty(repeatNewPassword):
raise ValueError(u"No master password changes detected")
if newPassword != repeatNewPassword:
raise ValueError(u"Passwords mismatch")
config = Config()
ck = config.getPrivateKey(unicode(currentPassword))
ck.save(config.privateKeyPath, unicode(newPassword))
logger.debug(u"Key exported")
def create_database(database):
db_config = Config.get('db')
conn = MySQLdb.connect(user=db_config.get('user'), passwd=db_config.get('password'), host=db_config.get('host'))
cursor = conn.cursor()
# MySQL generates a warning if we try to create a database that already exists even
# if we specify "IF NOT EXISTS" in the query.
import warnings
warnings.filterwarnings(action="ignore", category=MySQLdb.Warning,
message="Can't create database '{}'; database exists".format(database))
cursor.execute('CREATE DATABASE IF NOT EXISTS {}'.format(database))
def main():
config = Config()
handle = IrcHandle(config.return_config())
interaction = BotInteraction(config.return_config())
read_buffer = ""
while True: # While Connection is Active
read_buffer = read_buffer + handle.irc_socket.recv(1024)
temp = string.split(read_buffer, "\n")
read_buffer = temp.pop()
for line in temp:
interaction.check_ping(line)
return_message = interaction.handle_line(interaction.username,
interaction.message,
interaction.parts)
if interaction.ping:
handle.send_ping(interaction.ping)
else:
handle.send_message(return_message)
class SettingsPage(QWidget):
def __init__(self):
super(SettingsPage, self).__init__()
self.ui = Ui_SettingsPage()
self.ui.setupUi(self)
self.ui.information_label.setVisible(False)
self.ui.database_location_button.clicked.connect(self.selectDatabaseLocation)
self.ui.freerdp_executable_button.clicked.connect(self.selectFreerdpLocation)
self.ui.save_button.clicked.connect(self.saveSettings)
self.config = Config()
self.ui.database_location.setText(self.config.databaseLocation)
self.ui.freerdp_executable.setText(self.config.freerdpExecutable)
self.ui.freerdp_arguments.setText(self.config.freerdpArgs)
self.keyMenu = QMenu()
self.keyMenu.addAction('Set master password', self.setKeyPassword)
self.ui.master_key_button.setStyleSheet("QPushButton::menu-indicator {image: none;}")
self.ui.master_key_button.setMenu(self.keyMenu)
self.ui.logging_level.addItems(self.config.loggingLevels)
currentItem = self.ui.logging_level.findText(self.config.logLevel)
if currentItem != -1:
self.ui.logging_level.setCurrentIndex(currentItem)
@staticmethod
def setKeyPassword():
skp = SetKeyPassword()
skp.exec_()
def selectFreerdpLocation(self):
dialog = QFileDialog()
result = dialog.getOpenFileName(self, "Freerdp location", directory='/usr/bin')
if result != QtCore.QString(u''):
self.ui.freerdp_executable.setText(result)
def selectDatabaseLocation(self):
dialog = QFileDialog()
dialog.setFileMode(QFileDialog.AnyFile)
result = dialog.getSaveFileName(self, "Database location", filter="*.sqlite")
if result != QtCore.QString(u''):
self.ui.database_location.setText(result)
def saveSettings(self):
databaseLocationToSave = self.ui.database_location.text()
if self.config.databaseLocation != databaseLocationToSave:
self.config.setDatabaseLocation(self.ui.database_location.text())
self.ui.information_label.setVisible(True)
self.config.setFreerdpExecutable(self.ui.freerdp_executable.text())
self.config.setFreerdpArgs(self.ui.freerdp_arguments.text())
self.config.setLogLevel(self.ui.logging_level.currentText())
def __init__(self):
super(SettingsPage, self).__init__()
self.ui = Ui_SettingsPage()
self.ui.setupUi(self)
self.ui.information_label.setVisible(False)
self.ui.database_location_button.clicked.connect(self.selectDatabaseLocation)
self.ui.freerdp_executable_button.clicked.connect(self.selectFreerdpLocation)
self.ui.save_button.clicked.connect(self.saveSettings)
self.config = Config()
self.ui.database_location.setText(self.config.databaseLocation)
self.ui.freerdp_executable.setText(self.config.freerdpExecutable)
self.ui.freerdp_arguments.setText(self.config.freerdpArgs)
self.keyMenu = QMenu()
self.keyMenu.addAction('Set master password', self.setKeyPassword)
self.ui.master_key_button.setStyleSheet("QPushButton::menu-indicator {image: none;}")
self.ui.master_key_button.setMenu(self.keyMenu)
self.ui.logging_level.addItems(self.config.loggingLevels)
currentItem = self.ui.logging_level.findText(self.config.logLevel)
if currentItem != -1:
self.ui.logging_level.setCurrentIndex(currentItem)
def __init__(self, config):
super(MainWindow, self).__init__()
self.config = Config(config)
db = Database(self.config.getConnectionString())
db.create()
self.hosts = Hosts(db)
# menu used for each host
self.hostMenu = QMenu()
self.hostMenu.addAction(QIcon(":/ico/edit.svg"), "Edit", self.editHost)
self.hostMenu.addAction(QIcon(":/ico/remove.svg"), "Delete", self.deleteHost)
actions.addActionWithScreenChose(
self.hostMenu, self.connectFrameless, ":/ico/frameless.svg", "Connect frameless"
)
# setup main window
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# when top level changed, we changing dock title bar
self.dockWidgetTileBar = DockWidgetTitleBar()
self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar)
self.ui.hostsDock.topLevelChanged.connect(self.dockLevelChanged)
# set global menu
self.globalMenu = QMenu()
self.globalMenu.addAction(QIcon(":/ico/add.svg"), "Add host", self.addHost)
# disable menu indicator
self.ui.menu.setStyleSheet("QPushButton::menu-indicator {image: none;}")
self.positionMenu = QMenu("Dock position")
self.positionMenu.addAction("Left", lambda: self.setDockPosition(Qt.LeftDockWidgetArea))
self.positionMenu.addAction("Right", lambda: self.setDockPosition(Qt.RightDockWidgetArea))
self.positionMenu.addAction("Float", self.setDockFloat)
self.globalMenu.addMenu(self.positionMenu)
self.globalMenu.addAction("Change tray icon visibility", self.changeTrayIconVisibility)
self.globalMenu.addAction("Quit", self.close)
self.ui.menu.setMenu(self.globalMenu)
# set events on hosts list
self.ui.hostsList.itemDoubleClicked.connect(self.slotConnectHost)
self.ui.hostsList.itemClicked.connect(self.slotShowHost)
self.ui.hostsList.customContextMenuRequested.connect(self.slotShowHostContextMenu)
# set tab widget
self.tabWidget = MyTabWidget()
self.setCentralWidget(self.tabWidget)
# set tray icon
self.tray = QSystemTrayIcon(QIcon(":/ico/myrdp.svg"))
self.tray.activated.connect(self.trayActivated)
self.trayMenu = QMenu()
self.trayMenu.addAction("Hide tray icon", self.changeTrayIconVisibility)
self.trayMenu.addAction("Quit", self.close)
self.tray.setContextMenu(self.trayMenu)
# host list
self.ui.filter.textChanged.connect(self.setHostList)
self.setHostList()
self.restoreSettings()
from pyramid.config import Configurator
from wsgiref.simple_server import make_server
from app.api.core.routes import wire_routes
from app.config import Config
# Setup the api routes
config = Configurator()
wire_routes(config)
config.scan()
# Start the server
api_config = Config.get('api')
host = api_config.get('host')
port = api_config.get('port')
app = config.make_wsgi_app()
server = make_server(host, port, app)
print 'Started API on {}:{}'.format(host, port)
server.serve_forever()
def __init__(self, config_file = default_config_file_abs_name): #pylint:disable=W0231 self.executer = CommandExecuter() self.config_file_abs_name = config_file self.config_manager = ConfigManager( config_file ) self.config = Config(config_file)
class FsSeriesStore(SeriesStore):
""" Base class model for a set of Series managed by a bash store """
config_file_season_name = ".play_conf"
config_file_serie_name = ".play_season"
default_config_file_abs_name = Config.config_file_abs_name
path_to_series_var = "BASE"
play_current_episode_var = "CUR"
skip_time_var = "GENERICTIME"
decay_time_var = "DECALAGESUB"
serie_name_var = "NAME"
fps_var = "SUBFPS"
def __init__(self, config_file = default_config_file_abs_name):
#pylint:disable=W0231
self.executer = CommandExecuter()
self.config_file_abs_name = config_file
self.config_manager = ConfigManager( config_file )
self.config = Config(config_file)
# paths generator
def get_global_config_file(self):
""" Get Path to global user config file """
return os.path.expanduser(self.config_file_abs_name)
def get_absolute_path(self):
""" Get Root Path for Series storing"""
base = self.config_manager.read_conf_var(self.get_global_config_file(), \
self.path_to_series_var)
base = os.path.expanduser(base)
info("reading conf from file : {0}".format(base))
debug("base path : {}".format(base))
if not os.path.exists(base):
raise FileNameError(base)
return base
def get_path_to_serie(self, name):
""" Get path to serie @name
"""
base = self.get_absolute_path()
return os.path.join(base, name)
def get_path_to_current_season(self):
""" Get path to current season of currently viewed serie
"""
name = self.get_current_serie_name()
return self.get_path_to_current_season_of(name)
def get_serie_configfile(self, name):
""" Returns configfile for serie name @name """
return os.path.join(self.get_path_to_serie(name), self.config_file_serie_name)
def get_season_configfile(self, name, season):
""" returns season configfile for serie 'name' season 'season' """
return os.path.join(self.get_path_to_season(name, season),
self.config_file_season_name)
def get_path_to_current_season_of(self, name):
""" Get path to current season of a particular serie @name
"""
num = self.get_stored_current_season_number(name)
return self.get_path_to_season(name, num)
def get_path_to_season(self, name, numseason):
""" Get path to season @numseason of serie @name
"""
serie_path = self.get_path_to_serie(name)
pattern = '[Ss]*{}'.format(numseason)
full_pattern = os.path.join(serie_path, pattern)
candidates = glob.glob(full_pattern)
if len(candidates) == 0:
return os.path.join(serie_path, "Saison {}".format(numseason))
# raise Exception("Season {} path not found for '{}'".format(numsaison, name))
return candidates[0]
# config management
def read_conf_var(self, config_file_path, var_name, default=None):
""" Gets a value in a 'key=value' file format
@config_file_path : the file
@var_name : the key
"""
try:
return self.config_manager.read_conf_var(config_file_path, var_name)
finally:
pass
return default
def write_conf_var(self, config_file_path, var_name, value):
""" Writes a value in a 'key=value' file format
@config_file_path : the file
@var_name : the key
@value : the value
"""
return self.config_manager.write_conf_var(config_file_path, var_name, value)
def read_num_conf_var(self, config_file_path, var_name, default = None):
""" Reads a numeric value in a 'key=value' file format
@config_file_path : the file
@var_name : the key
"""
value = default
try:
value = self.config_manager.read_num_conf_var(config_file_path, var_name)
except Exception:
pass
return value
# finally:
# return default
def get_conf_variable(self, name, numseason, var_name):
""" Gets value of a variable stored for a specified @numseason season
of a specified serie @name. """
return self.read_conf_var(self.get_path_to_season(name, numseason), var_name)
def get_num_conf_variable(self, name, numseason, var_name):
""" same as get_conf_variable for a Numeric value """
return self.read_num_conf_var(
self.get_path_to_season(name, numseason),
var_name)
# useful data getters
def get_current_serie_name(self):
""" Returns the name of current serie """
return self.config_manager.read_var("NAME")
def get_stored_current_season_number(self, name):
""" Returns season number of current serie """
serie_conf_file = self.get_serie_configfile(name)
num = self.read_num_conf_var(serie_conf_file, "SEASON", 1)
return num
def get_serie_list(self):
""" Returns the list of series name
on the directory """
serie_path = self.get_absolute_path()
dirs = [ x for x in os.listdir(serie_path)
if os.path.isdir(os.path.join(serie_path, x)) ]
return dirs
def create_season_storage(self, serie_name, season_num):
""" Create season directory for serie 'serie_name' season 'season_num'"""
serie_path = self.get_path_to_serie(serie_name)
dir_name = "Saison {}".format(season_num)
full_season_path = os.path.join(serie_path, dir_name)
os.mkdir(full_season_path)
with open( self.get_season_configfile(serie_name, \
season_num) ,'w') as fic:
fic.write("""CUR='1'\nGENERICTIME='0'""")
def get_current_stored_episode(self, serie_name, season_num):
""" Returns current episode number in disk store
"""
ficname = ""
season_path = None
try:
season_path = self.get_path_to_season(serie_name, \
season_num)
except Exception :
self.create_season_storage(serie_name, season_num)
season_path = self.get_path_to_season(serie_name,
season_num)
ficname = os.path.join( season_path, \
self.config_file_season_name )
if os.path.exists(ficname):
return self.read_num_conf_var(ficname, \
self.play_current_episode_var)
return None
# raise Exception("Unexisting config file {}".format(ficname))
def get_subtitle_candidates(self, serie_name, season_num, num_ep):
""" Returns the list of filename candidates for subtitles
for @serie_name, for season number @season_num, episode @num_ep
"""
extensions = self.config.get_sub_extensions()
result = self._get_candidates(serie_name, season_num, num_ep, extensions)
return result
def get_video_candidates(self, serie_name, season_num, num_ep):
""" Returns the list of filename candidates for video
for @serie_name, for season number @season_num, episode @num_ep
"""
extensions = self.config.get_video_extensions()
result = self._get_candidates(serie_name, season_num, num_ep, extensions)
assert(len(result)>=0)
return result
def get_glob_pattern(self, season_num, num_ep, ext_list = None):
""" Get globbing pattern
"""
patterns = ['({season:02d}|{season:d}).*{ep:02d}[^0-9]',
'[sS]{season:02d}[^0-9]( )?[xeE]{ep:02d}[^0-9]'
]
pattern = "({})".format("|".join(patterns))
pattern = pattern.format(season = season_num, \
ep = num_ep)
if ext_list:
pattern = '({}.*)\.({})'.format(pattern, "|".join(ext_list))
return pattern
def _get_candidates_in_path(self, path, season_num, num_ep, option):
""" return matching filenames in path 'path' as "path/filename" list """
result = []
if(os.path.exists(path)):
re_pattern = self.get_glob_pattern(season_num, num_ep, option)
regex = re.compile(re_pattern)
all_files = os.listdir(path)
direct = [ os.path.join(path, x) for x in all_files
if regex.search(x) ]
result = direct
return result
def _get_candidates(self, serie_name, season_num, num_ep, option):
""" calls candidates finder bash script """
path = self.get_path_to_season(serie_name, season_num)
result = []
if os.path.exists(path):
all_files = os.listdir(path)
direct = self._get_candidates_in_path(
path,
season_num, num_ep, option) #[ x for x in all_files
#if regex.search(x) ]
re_dir_pattern = re.compile(self.get_glob_pattern(season_num, num_ep))
sub_dirs = [ os.path.join(path, x) for x in all_files
if os.path.isdir(os.path.join(path, x))
and re_dir_pattern.search(x) ]
subdir_candidates = [ candidate for dirs in sub_dirs
for candidate in \
self._get_candidates_in_path(dirs, season_num, num_ep, option)
]
result = direct + subdir_candidates
assert(len(result)>=0)
return result
def __init__(self):
super(MainWindow, self).__init__()
self.config = Config()
self.db = Database(self.config.getConnectionString())
cryptoKey = self.getCryptoKey()
self.hosts = Hosts(self.db, cryptoKey)
# menu used for each host
self.hostMenu = QMenu()
self.editAction = QAction(QIcon(':/ico/edit.svg'), "Edit", self.hostMenu)
self.editAction.triggered.connect(self.editHost)
self.hostMenu.addAction(self.editAction)
# menu used for headers of groups
self.groupsHeaderMenu = QMenu()
self.editGroupAction = QAction(QIcon(':/ico/edit.svg'), "Edit group", self.groupsHeaderMenu)
self.editGroupAction.triggered.connect(self.editGroup)
self.deleteGroupAction = QAction(QIcon(':/ico/remove.svg'), "Delete group", self.groupsHeaderMenu)
self.deleteGroupAction.triggered.connect(self.deleteGroup)
self.groupsHeaderMenu.addAction(self.editGroupAction)
self.groupsHeaderMenu.addAction(self.deleteGroupAction)
self.duplicateAction = QAction(QIcon(':/ico/copy.svg'), "Duplicate", self.hostMenu)
self.duplicateAction.triggered.connect(self.duplicateHost)
self.hostMenu.addAction(self.duplicateAction)
# todo: confirm for delete action
self.deleteAction = QAction(QIcon(':/ico/remove.svg'), "Delete", self.hostMenu)
self.deleteAction.triggered.connect(self.deleteHost)
self.hostMenu.addAction(self.deleteAction)
self.connectFramelessMenu = actions.generateScreenChoseMenu(self.hostMenu, self.connectFrameless,
':/ico/frameless.svg', "Connect frameless")
self.hostMenu.addMenu(self.connectFramelessMenu)
self.assignGroupAction = QAction("Assign group", self.hostMenu)
self.assignGroupAction.triggered.connect(self.assignGroup)
self.hostMenu.addAction(self.assignGroupAction)
# setup main window
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# when top level changed, we changing dock title bar
self.dockWidgetTileBar = DockWidgetTitleBar()
self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar)
self.ui.hostsDock.topLevelChanged.connect(self.dockLevelChanged)
# set global menu
self.globalMenu = QMenu()
self.globalMenu.addAction(QIcon(':/ico/add.svg'), 'Add host', self.addHost)
# groups menu
self.groupsMenu = QMenu("Groups")
self.groupsMenu.aboutToShow.connect(self.setGroupsMenu)
self.globalMenu.addMenu(self.groupsMenu)
# disable menu indicator
self.ui.menu.setStyleSheet("QPushButton::menu-indicator {image: none;}")
self.positionMenu = QMenu("Dock position")
self.positionMenu.addAction("Left", lambda: self.setDockPosition(Qt.LeftDockWidgetArea))
self.positionMenu.addAction("Right", lambda: self.setDockPosition(Qt.RightDockWidgetArea))
self.positionMenu.addAction("Float", self.setDockFloat)
self.globalMenu.addMenu(self.positionMenu)
self.globalMenu.addAction('Change tray icon visibility', self.changeTrayIconVisibility)
self.globalMenu.addAction('Settings', self.showSettings)
self.globalMenu.addAction('Quit', self.close)
self.ui.menu.setMenu(self.globalMenu)
# set events on hosts list
self.ui.hostsList.itemDoubleClicked.connect(self.slotConnectHost)
self.ui.hostsList.itemClicked.connect(self.slotShowHost)
self.ui.hostsList.customContextMenuRequested.connect(self.slotShowHostContextMenu)
# set tab widget
self.tabWidget = MyTabWidget()
self.setCentralWidget(self.tabWidget)
self.tabWidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.tabWidget.customContextMenuRequested.connect(self.showCentralWidgetContextMenu)
# set tray icon
self.tray = QSystemTrayIcon(QIcon(":/ico/myrdp.svg"))
self.tray.activated.connect(self.trayActivated)
self.trayMenu = QMenu()
self.trayMenu.addAction("Hide tray icon", self.changeTrayIconVisibility)
self.connectHostMenuTray = ConnectHostMenu(self.hosts)
self.connectHostMenuTray.triggered.connect(self.connectHostFromTrayMenu)
self.trayMenu.addMenu(self.connectHostMenuTray)
self.trayMenu.addAction("Quit", self.close)
self.tray.setContextMenu(self.trayMenu)
self.restoreSettings()
# host list
self.ui.filter.textChanged.connect(self.setHostList)
self.setHostList()
class MainWindow(QMainWindow):
groups = dict()
typeQListWidgetHeader = 1000
showHostsInGroups = False
currentGroupName = None # used to simple detect currently selected group to show menu
def __init__(self):
super(MainWindow, self).__init__()
self.config = Config()
self.db = Database(self.config.getConnectionString())
cryptoKey = self.getCryptoKey()
self.hosts = Hosts(self.db, cryptoKey)
# menu used for each host
self.hostMenu = QMenu()
self.editAction = QAction(QIcon(':/ico/edit.svg'), "Edit", self.hostMenu)
self.editAction.triggered.connect(self.editHost)
self.hostMenu.addAction(self.editAction)
# menu used for headers of groups
self.groupsHeaderMenu = QMenu()
self.editGroupAction = QAction(QIcon(':/ico/edit.svg'), "Edit group", self.groupsHeaderMenu)
self.editGroupAction.triggered.connect(self.editGroup)
self.deleteGroupAction = QAction(QIcon(':/ico/remove.svg'), "Delete group", self.groupsHeaderMenu)
self.deleteGroupAction.triggered.connect(self.deleteGroup)
self.groupsHeaderMenu.addAction(self.editGroupAction)
self.groupsHeaderMenu.addAction(self.deleteGroupAction)
self.duplicateAction = QAction(QIcon(':/ico/copy.svg'), "Duplicate", self.hostMenu)
self.duplicateAction.triggered.connect(self.duplicateHost)
self.hostMenu.addAction(self.duplicateAction)
# todo: confirm for delete action
self.deleteAction = QAction(QIcon(':/ico/remove.svg'), "Delete", self.hostMenu)
self.deleteAction.triggered.connect(self.deleteHost)
self.hostMenu.addAction(self.deleteAction)
self.connectFramelessMenu = actions.generateScreenChoseMenu(self.hostMenu, self.connectFrameless,
':/ico/frameless.svg', "Connect frameless")
self.hostMenu.addMenu(self.connectFramelessMenu)
self.assignGroupAction = QAction("Assign group", self.hostMenu)
self.assignGroupAction.triggered.connect(self.assignGroup)
self.hostMenu.addAction(self.assignGroupAction)
# setup main window
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# when top level changed, we changing dock title bar
self.dockWidgetTileBar = DockWidgetTitleBar()
self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar)
self.ui.hostsDock.topLevelChanged.connect(self.dockLevelChanged)
# set global menu
self.globalMenu = QMenu()
self.globalMenu.addAction(QIcon(':/ico/add.svg'), 'Add host', self.addHost)
# groups menu
self.groupsMenu = QMenu("Groups")
self.groupsMenu.aboutToShow.connect(self.setGroupsMenu)
self.globalMenu.addMenu(self.groupsMenu)
# disable menu indicator
self.ui.menu.setStyleSheet("QPushButton::menu-indicator {image: none;}")
self.positionMenu = QMenu("Dock position")
self.positionMenu.addAction("Left", lambda: self.setDockPosition(Qt.LeftDockWidgetArea))
self.positionMenu.addAction("Right", lambda: self.setDockPosition(Qt.RightDockWidgetArea))
self.positionMenu.addAction("Float", self.setDockFloat)
self.globalMenu.addMenu(self.positionMenu)
self.globalMenu.addAction('Change tray icon visibility', self.changeTrayIconVisibility)
self.globalMenu.addAction('Settings', self.showSettings)
self.globalMenu.addAction('Quit', self.close)
self.ui.menu.setMenu(self.globalMenu)
# set events on hosts list
self.ui.hostsList.itemDoubleClicked.connect(self.slotConnectHost)
self.ui.hostsList.itemClicked.connect(self.slotShowHost)
self.ui.hostsList.customContextMenuRequested.connect(self.slotShowHostContextMenu)
# set tab widget
self.tabWidget = MyTabWidget()
self.setCentralWidget(self.tabWidget)
self.tabWidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.tabWidget.customContextMenuRequested.connect(self.showCentralWidgetContextMenu)
# set tray icon
self.tray = QSystemTrayIcon(QIcon(":/ico/myrdp.svg"))
self.tray.activated.connect(self.trayActivated)
self.trayMenu = QMenu()
self.trayMenu.addAction("Hide tray icon", self.changeTrayIconVisibility)
self.connectHostMenuTray = ConnectHostMenu(self.hosts)
self.connectHostMenuTray.triggered.connect(self.connectHostFromTrayMenu)
self.trayMenu.addMenu(self.connectHostMenuTray)
self.trayMenu.addAction("Quit", self.close)
self.tray.setContextMenu(self.trayMenu)
self.restoreSettings()
# host list
self.ui.filter.textChanged.connect(self.setHostList)
self.setHostList()
def getCryptoKey(self, passphrase=None):
try:
return self.config.getPrivateKey(passphrase)
except ValueError:
passwordDialog = PasswordDialog()
retCode = passwordDialog.exec_()
if retCode == QtGui.QDialog.Accepted:
return self.getCryptoKey(passwordDialog.getPassword())
else:
raise SystemError("Password required")
def showSettings(self):
settingsWidget = self.findChild(QWidget, "settings")
if settingsWidget is None:
self.settingsWidget = SettingsPage()
self.settingsWidget.setObjectName("settings")
self.tabWidget.insertTab(0, self.settingsWidget, QIcon(":/ico/settings.svg"), 'Settings')
index = self.tabWidget.indexOf(self.settingsWidget)
self.tabWidget.setCurrentIndex(index)
def connectHostFromMenu(self, action):
self.connectHost(unicode(action.text()))
def connectHostFromTrayMenu(self, action):
tabPage = self.connectHost(unicode(action.text()))
if not self.isVisible():
self.tabWidget.setDetached(True, tabPage)
def trayActivated(self, reason):
if reason != QSystemTrayIcon.Trigger:
return
if self.isVisible():
self.hide()
else:
self.show()
self.activateWindow()
def changeTrayIconVisibility(self):
if self.tray.isVisible():
self.tray.hide()
if not self.isVisible():
self.show()
else:
self.tray.show()
def refreshGroups(self):
groupList = self.hosts.getGroupsList()
for group in groupList:
if group not in self.groups:
# add new groups as visible
self.groups[group] = True
# remove not existing groups
keysToDelete = set(self.groups.keys()) - set(groupList)
for key in keysToDelete:
self.groups.pop(key)
def assignGroup(self):
groups = self.hosts.getGroupsList()
assignGroupDialog = AssignGroupDialog(groups)
groupToAssign = assignGroupDialog.assign()
if groupToAssign is not False: # None could be used to unassign the group
groupToAssign = None if groupToAssign.isEmpty() else unicode(groupToAssign)
for hostName in self.getSelectedHosts():
self.hosts.assignGroup(hostName, groupToAssign)
self.db.tryCommit()
self.setHostList()
def setGroupsMenu(self):
self.groupsMenu.clear()
addGroupAction = self.groupsMenu.addAction('Add group')
addGroupAction.triggered.connect(self.addGroup)
deleteGroupAction = self.groupsMenu.addAction('Delete group')
deleteGroupAction.triggered.connect(self.showDeleteGroupDialog)
showHostsInGroupsAction = self.groupsMenu.addAction('Show host list in groups')
showHostsInGroupsAction.triggered.connect(self.changeHostListView)
showHostsInGroupsAction.setCheckable(True)
showHostsInGroupsAction.setChecked(self.showHostsInGroups)
self.groupsMenu.addSeparator()
for group, checked in self.groups.items():
action = QAction(group, self.groupsMenu)
action.setCheckable(True)
action.setChecked(checked)
action.triggered.connect(self.groupsVisibilityChanged)
self.groupsMenu.addAction(action)
def addGroup(self):
groupConfigDialog = GroupConfigDialog(self.hosts.groups)
resp = groupConfigDialog.add()
self._processHostSubmit(resp)
def groupsVisibilityChanged(self, checked):
currentGroup = unicode(self.sender().text())
self.groups[currentGroup] = checked
self.setHostList()
def setDockPosition(self, dockWidgetArea):
if self.ui.hostsDock.isFloating():
self.ui.hostsDock.setFloating(False)
self.addDockWidget(dockWidgetArea, self.ui.hostsDock)
def setDockFloat(self):
if self.ui.hostsDock.isFloating():
return
# default title bar must be set before is float because sometimes window make strange crash
self.ui.hostsDock.setTitleBarWidget(None)
self.ui.hostsDock.setFloating(True)
def dockLevelChanged(self, isFloating):
if isFloating:
# changing title bar widget if is not none, probably true will be only once on start with saved float state
if self.ui.hostsDock.titleBarWidget():
self.ui.hostsDock.setTitleBarWidget(None)
else:
self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar)
def showFramelessWidget(self):
self.t.show()
self.t.setGeometry(self.frameGeometry())
def getCurrentHostListItemName(self):
return self.ui.hostsList.currentItem().text()
def getSelectedHosts(self):
return [host.text() for host in self.ui.hostsList.selectedItems()]
def findHostItemByName(self, name):
result = self.ui.hostsList.findItems(name, Qt.MatchExactly)
resultLen = len(result)
if resultLen != 1: # should be only one host
logger.error("Host not found. Got %d results" % resultLen)
return result[0]
def showCentralWidgetContextMenu(self, pos):
menu = QMenu()
title = self.ui.hostsDock.windowTitle()
hostsDockAction = menu.addAction(title)
hostsDockAction.setCheckable(True)
hostsDockAction.setChecked(self.ui.hostsDock.isVisible())
hostsDockAction.triggered.connect(self.changeHostsDockWidgetVisibility)
hostsDockAction = menu.addAction("Tray icon")
hostsDockAction.setCheckable(True)
hostsDockAction.setChecked(self.tray.isVisible())
hostsDockAction.triggered.connect(self.changeTrayIconVisibility)
connectHostMenuTray = ConnectHostMenu(self.hosts, "Connect")
connectHostMenuTray.triggered.connect(self.connectHostFromMenu)
menu.addMenu(connectHostMenuTray)
menu.exec_(self.tabWidget.mapToGlobal(pos))
def changeHostListView(self, checked):
self.showHostsInGroups = checked
self.setHostList()
def changeHostsDockWidgetVisibility(self):
isVisible = self.ui.hostsDock.isVisible()
self.ui.hostsDock.setVisible(not isVisible)
def isHostListHeader(self, item):
if not item or item.type() == self.typeQListWidgetHeader:
return True
return False
def slotShowHostContextMenu(self, pos):
def changeMenusVisibility(isEnabled):
self.connectFramelessMenu.setEnabled(isEnabled)
self.editAction.setEnabled(isEnabled)
self.duplicateAction.setEnabled(isEnabled)
# ignore context menu for group headers
item = self.ui.hostsList.itemAt(pos)
if self.isHostListHeader(item):
item = self.ui.hostsList.itemAt(pos)
widgetItem = self.ui.hostsList.itemWidget(item)
if widgetItem:
self.currentGroupName = widgetItem.text() # yea I'm so dirty
if self.currentGroupName != unassignedGroupName:
self.groupsHeaderMenu.exec_(self.ui.hostsList.mapToGlobal(pos))
return
if len(self.ui.hostsList.selectedItems()) == 1: # single menu
changeMenusVisibility(True)
else:
changeMenusVisibility(False)
self.hostMenu.exec_(self.ui.hostsList.mapToGlobal(pos))
def _processHostSubmit(self, resp):
if resp["code"]:
self.setHostList()
hostName = resp.get("name")
if hostName:
hostItem = self.findHostItemByName(hostName)
self.slotConnectHost(hostItem)
def addHost(self):
hostDialog = HostConfigDialog(self.hosts)
self._processHostSubmit(hostDialog.add())
def editHost(self):
hostDialog = HostConfigDialog(self.hosts)
resp = hostDialog.edit(self.getCurrentHostListItemName())
self._processHostSubmit(resp)
def editGroup(self):
groupConfigDialog = GroupConfigDialog(self.hosts.groups)
resp = groupConfigDialog.edit(self.currentGroupName)
self._processHostSubmit(resp)
def deleteGroup(self):
retCode = self.showOkCancelMessageBox("Do you want to remove selected group? All assigned hosts "
"to this group will be unassigned.",
"Confirmation")
if retCode == QMessageBox.Cancel:
return
self.hosts.deleteGroup(self.currentGroupName)
self.setHostList()
def showDeleteGroupDialog(self):
deleteGroupDialog = DeleteGroupDialog(self.hosts)
deleteGroupDialog.deleteGroup()
self.setHostList()
def duplicateHost(self):
hostDialog = HostConfigDialog(self.hosts)
resp = hostDialog.duplicate(self.getCurrentHostListItemName())
self._processHostSubmit(resp)
def deleteHost(self):
retCode = self.showOkCancelMessageBox("Do you want to remove selected hosts?",
"Confirmation")
if retCode == QMessageBox.Cancel:
return
for host in self.getSelectedHosts():
self.hosts.delete(host)
self.setHostList()
def connectFrameless(self, screenIndex=None):
self.connectHost(self.getCurrentHostListItemName(), frameless=True, screenIndex=screenIndex)
# Fix to release keyboard from QX11EmbedContainer, when we leave widget through wm border
def leaveEvent(self, event):
keyG = QWidget.keyboardGrabber()
if keyG is not None:
keyG.releaseKeyboard()
event.accept() # needed?
def setHostList(self):
""" set hosts list in list view """
self.ui.hostsList.clear()
self.refreshGroups()
hostFilter = self.ui.filter.text()
if self.showHostsInGroups:
self.showHostListInGroups(hostFilter)
else:
self.showHostList(hostFilter)
def showHostList(self, hostFilter):
groupFilter = [group for group, visibility in self.groups.items() if visibility]
hosts = self.hosts.getHostsListByHostNameAndGroup(hostFilter, groupFilter)
self.ui.hostsList.addItems(hosts)
def showHostListInGroups(self, hostFilter):
hosts = self.hosts.getGroupedHostNames(hostFilter)
for group, hostsList in hosts.items():
if self.groups.get(group, True):
if group is None:
group = unassignedGroupName
groupHeader = QtGui.QListWidgetItem(type=self.typeQListWidgetHeader)
groupLabel = QtGui.QLabel(unicode(group))
groupLabel.setProperty('class', 'group-title')
self.ui.hostsList.addItem(groupHeader)
self.ui.hostsList.setItemWidget(groupHeader, groupLabel)
self.ui.hostsList.addItems(hostsList)
def slotShowHost(self, item):
# on one click we activating tab and showing options
self.tabWidget.activateTab(item)
def slotConnectHost(self, item):
if self.isHostListHeader(item):
return
self.connectHost(unicode(item.text()))
def connectHost(self, hostId, frameless=False, screenIndex=None):
hostId = unicode(hostId) # sometimes hostId comes as QString
tabPage = self.tabWidget.createTab(hostId)
tabPage.reconnectionNeeded.connect(self.connectHost)
if frameless:
self.tabWidget.detachFrameless(tabPage, screenIndex)
try:
execCmd, opts = self.getCmd(tabPage, hostId)
except LookupError:
logger.error(u"Host {} not found.".format(hostId))
return
ProcessManager.start(hostId, tabPage, execCmd, opts)
return tabPage
def getCmd(self, tabPage, hostName):
host = self.hosts.get(hostName)
# set tabPage widget
width, height = tabPage.setSizeAndGetCurrent()
# 1et widget winId to embed rdesktop
winId = tabPage.x11.winId()
# set remote desktop client, at this time works only with freerdp
remoteClientType, remoteClientOptions = self.config.getRdpClient()
remoteClient = ClientFactory(remoteClientType, **remoteClientOptions)
remoteClient.setWindowParameters(winId, width, height)
remoteClient.setUserAndPassword(host.user, host.password)
remoteClient.setAddress(host.address)
return remoteClient.getComposedCommand()
def saveSettings(self):
self.config.setValue("geometry", self.saveGeometry())
self.config.setValue("windowState", self.saveState())
self.config.setValue('trayIconVisibility', self.tray.isVisible())
self.config.setValue('mainWindowVisibility', self.isVisible())
self.config.setValue('groups', self.groups)
self.config.setValue('showHostsInGroups', self.showHostsInGroups)
def restoreSettings(self):
try:
self.restoreGeometry(self.config.getValue("geometry").toByteArray())
self.restoreState(self.config.getValue("windowState").toByteArray())
except Exception:
logger.debug("No settings to restore")
# restore tray icon state
trayIconVisibility = self.config.getValue('trayIconVisibility', "true").toBool()
self.tray.setVisible(trayIconVisibility)
self.showHostsInGroups = self.config.getValue('showHostsInGroups', 'false').toBool()
if self.tray.isVisible():
mainWindowVisibility = self.config.getValue('mainWindowVisibility', "true").toBool()
self.setVisible(mainWindowVisibility)
else: # it tray icon is not visible, always show main window
self.show()
self.groups = {unicode(k): v for k, v in self.config.getValue('groups', {}).toPyObject().items()}
def closeEvent(self, event):
if not ProcessManager.hasActiveProcess:
self.saveSettings()
QCoreApplication.exit()
return
ret = self.showOkCancelMessageBox("Are you sure do you want to quit?",
"Exit confirmation")
if ret == QMessageBox.Cancel:
event.ignore()
return
self.saveSettings()
ProcessManager.killemall()
event.accept()
QCoreApplication.exit()
def showOkCancelMessageBox(self, messageBoxText, windowTitle):
msgBox = QMessageBox(self, text=messageBoxText)
msgBox.setWindowTitle(windowTitle)
msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
msgBox.setIcon(QMessageBox.Question)
return msgBox.exec_()
def test_conf_read(self):
config = Config(self.path)
config.load_config_from_json()
config.parse()
spark_master = config.get_spark_master()
print spark_master
from mysql import MySQL
from app.config import Config
# Create the database from the config
MySQL.create_database(Config.get('db').get('database'))
MySQL.run('''
CREATE TABLE IF NOT EXISTS user (
user_id INT(8) UNSIGNED,
creation_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (user_id)
)
''')
MySQL.run('''
CREATE TABLE IF NOT EXISTS user_device (
device_id INT(8) UNSIGNED,
user_id INT(8) UNSIGNED,
platform VARCHAR(255) CHARACTER SET utf8,
system_version VARCHAR(255) CHARACTER SET utf8,
app_version VARCHAR(255) CHARACTER SET utf8,
push_token VARCHAR(255) CHARACTER SET utf8,
creation_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
last_seen TIMESTAMP,
PRIMARY KEY (device_id)
)
''')
MySQL.run('''
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)
from app.api.core.utils import api
from app.config import Config
from app.db.user_address import UserAddress
from app.exception import MyBitsException
blockcypher_config = Config.get('blockcypher')
api_key = blockcypher_config.get('api_key')
@api(enforce_user=True)
def add(context, request, api_version, user,
address=None):
if not address:
raise MyBitsException('Parameter `address` missing')
# Store the user address in DB
UserAddress.add(user.user_id, address, 'XPUB')
def get_connection():
if not MySQL._conn:
db_config = Config.get('db')
MySQL._conn = MySQLdb.connect(user=db_config.get('user'), passwd=db_config.get('password'),
host=db_config.get('host'), db=db_config.get('database'))
return MySQL._conn
def assertPath(self, path):
try:
c = Config(path)
except IOError as e:
self.fail(unicode(e))
c._drop()
if __name__ == "__main__":
app = QApplication(sys.argv)
styleFile = QFile(":/style/style.qss")
styleFile.open(QFile.ReadOnly)
data = styleFile.readAll()
app.setStyleSheet(unicode(data))
# show icons in menus
app.setAttribute(Qt.AA_DontShowIconsInMenus, False)
app.setQuitOnLastWindowClosed(False)
# finish app with ctrl+c
signal.signal(signal.SIGINT, signal.SIG_DFL)
app.focusChanged.connect(focusChanged)
config = Config()
config.setLogLevel()
db = Database(config.getConnectionString())
db.create()
db.update()
mw = MainWindow()
app.exec_()
app.deleteLater()
sys.exit(0)
class MainWindow(QMainWindow):
def __init__(self, config):
super(MainWindow, self).__init__()
self.config = Config(config)
db = Database(self.config.getConnectionString())
db.create()
self.hosts = Hosts(db)
# menu used for each host
self.hostMenu = QMenu()
self.hostMenu.addAction(QIcon(":/ico/edit.svg"), "Edit", self.editHost)
self.hostMenu.addAction(QIcon(":/ico/remove.svg"), "Delete", self.deleteHost)
actions.addActionWithScreenChose(
self.hostMenu, self.connectFrameless, ":/ico/frameless.svg", "Connect frameless"
)
# setup main window
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# when top level changed, we changing dock title bar
self.dockWidgetTileBar = DockWidgetTitleBar()
self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar)
self.ui.hostsDock.topLevelChanged.connect(self.dockLevelChanged)
# set global menu
self.globalMenu = QMenu()
self.globalMenu.addAction(QIcon(":/ico/add.svg"), "Add host", self.addHost)
# disable menu indicator
self.ui.menu.setStyleSheet("QPushButton::menu-indicator {image: none;}")
self.positionMenu = QMenu("Dock position")
self.positionMenu.addAction("Left", lambda: self.setDockPosition(Qt.LeftDockWidgetArea))
self.positionMenu.addAction("Right", lambda: self.setDockPosition(Qt.RightDockWidgetArea))
self.positionMenu.addAction("Float", self.setDockFloat)
self.globalMenu.addMenu(self.positionMenu)
self.globalMenu.addAction("Change tray icon visibility", self.changeTrayIconVisibility)
self.globalMenu.addAction("Quit", self.close)
self.ui.menu.setMenu(self.globalMenu)
# set events on hosts list
self.ui.hostsList.itemDoubleClicked.connect(self.slotConnectHost)
self.ui.hostsList.itemClicked.connect(self.slotShowHost)
self.ui.hostsList.customContextMenuRequested.connect(self.slotShowHostContextMenu)
# set tab widget
self.tabWidget = MyTabWidget()
self.setCentralWidget(self.tabWidget)
# set tray icon
self.tray = QSystemTrayIcon(QIcon(":/ico/myrdp.svg"))
self.tray.activated.connect(self.trayActivated)
self.trayMenu = QMenu()
self.trayMenu.addAction("Hide tray icon", self.changeTrayIconVisibility)
self.trayMenu.addAction("Quit", self.close)
self.tray.setContextMenu(self.trayMenu)
# host list
self.ui.filter.textChanged.connect(self.setHostList)
self.setHostList()
self.restoreSettings()
def trayActivated(self, reason):
if reason != QSystemTrayIcon.Trigger:
return
if self.isVisible():
self.hide()
else:
self.show()
self.activateWindow()
def changeTrayIconVisibility(self):
if self.tray.isVisible():
self.tray.hide()
if not self.isVisible():
self.show()
else:
self.tray.show()
def setDockPosition(self, dockWidgetArea):
if self.ui.hostsDock.isFloating():
self.ui.hostsDock.setFloating(False)
self.addDockWidget(dockWidgetArea, self.ui.hostsDock)
def setDockFloat(self):
if self.ui.hostsDock.isFloating():
return
# default title bar must be set before is float because sometimes window make strange crash
self.ui.hostsDock.setTitleBarWidget(None)
self.ui.hostsDock.setFloating(True)
def dockLevelChanged(self, isFloating):
if isFloating:
# changing title bar widget if is not none, probably true will be only once on start with saved float state
if self.ui.hostsDock.titleBarWidget():
self.ui.hostsDock.setTitleBarWidget(None)
else:
self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar)
def showFramelessWidget(self):
self.t.show()
self.t.setGeometry(self.frameGeometry())
def getCurrentHostListItemName(self):
return self.ui.hostsList.currentItem().text()
def findHostItemByName(self, name):
result = self.ui.hostsList.findItems(name, Qt.MatchExactly)
resultLen = len(result)
if resultLen != 1: # should be only one host
logging.error("Host not found. Got %d results" % resultLen)
return result[0]
def slotShowHostContextMenu(self, pos):
""" slot needed to show menu in proper position, or i'm doing something wrong
"""
self.hostMenu.exec_(self.ui.hostsList.mapToGlobal(pos))
def addHost(self):
hostDialog = HostConfigDialog(self.hosts)
resp = hostDialog.add()
if resp["code"]:
self.setHostList()
hostName = resp.get("name")
if hostName:
hostItem = self.findHostItemByName(hostName)
self.slotConnectHost(hostItem)
def editHost(self):
hostDialog = HostConfigDialog(self.hosts)
resp = hostDialog.edit(self.getCurrentHostListItemName())
if resp["code"]:
self.setHostList()
def deleteHost(self):
self.hosts.delete(self.getCurrentHostListItemName())
self.setHostList()
def connectFrameless(self, screenIndex=None):
self.connectHost(self.getCurrentHostListItemName(), frameless=True, screenIndex=screenIndex)
# Fix to release keyboard from QX11EmbedContainer, when we leave widget through wm border
def leaveEvent(self, event):
keyG = QWidget.keyboardGrabber()
if keyG is not None:
keyG.releaseKeyboard()
event.accept() # needed?
def setHostList(self):
""" set hosts list in list view """
self.ui.hostsList.clear()
self.ui.hostsList.addItems(self.hosts.getFilteredHostsNames(self.ui.filter.text()))
def slotShowHost(self, item):
# on one click we activating tab and showing options
self.tabWidget.activateTab(item)
def slotConnectHost(self, item):
self.connectHost(unicode(item.text()))
def connectHost(self, hostId, frameless=False, screenIndex=None):
hostId = unicode(hostId) # sometimes hostId comes as QString
tabPage = self.tabWidget.createTab(hostId)
tabPage.reconnectionNeeded.connect(self.connectHost)
if frameless:
self.tabWidget.detachFrameless(tabPage, screenIndex)
execCmd, opts = self.getCmd(tabPage, hostId)
ProcessManager.start(hostId, tabPage, execCmd, opts)
def getCmd(self, tabPage, hostName):
host = self.hosts.get(hostName)
# set tabPage widget
width, height = tabPage.setSizeAndGetCurrent()
# 1et widget winId to embed rdesktop
winId = tabPage.x11.winId()
# set remote desktop client, at this time works only with freerdp
remoteClientType, remoteClientOptions = self.config.getRdpClient()
remoteClient = ClientFactory(remoteClientType, **remoteClientOptions)
remoteClient.setWindowParameters(winId, width, height)
remoteClient.setUserAndPassword(host.user, host.password)
remoteClient.setAddress(host.address)
return remoteClient.getComposedCommand()
def saveSettings(self):
settings = QSettings("MyRDP")
settings.setValue("geometry", self.saveGeometry())
settings.setValue("windowState", self.saveState())
settings.setValue("trayIconVisibility", self.tray.isVisible())
def restoreSettings(self):
settings = QSettings("MyRDP")
try:
self.restoreGeometry(settings.value("geometry").toByteArray())
self.restoreState(settings.value("windowState").toByteArray())
except Exception:
logging.debug("No settings to restore")
# restore tray icon state
trayIconVisibility = settings.value("trayIconVisibility").toBool()
self.tray.setVisible(trayIconVisibility)
def closeEvent(self, event):
if not ProcessManager.hasActiveProcess:
self.saveSettings()
return
msgBox = QMessageBox(self, text="Are you sure do you want to quit?")
msgBox.setWindowTitle("Exit confirmation")
msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
ret = msgBox.exec_()
if ret == QMessageBox.Cancel:
event.ignore()
return
self.saveSettings()
ProcessManager.killemall()
event.accept()
