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 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__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()