def main(): f = open("food_diary.json", 'r') try: data = json.load(f) except: data = {} c = open('calories.json', 'r') try: calories = json.load(c) except: calories = {} f.close() c.close() cal = Calories(calories) fd = FoodDiary(data, cal) cli = CLI(fd) cli.start() f = open("food_diary.json", 'w') json.dump(data, f, indent=4) f.close() c = open("calories.json", 'w') json.dump(calories, c, indent=4) c.close()
def createCLI(self): cli = CLI(self.num) # cli.logging(False) cli.log('Starting Up') # this maps the CLI looks pretty time.sleep(1) cli.log('Loading 3...') time.sleep(1) cli.log('Loading 2...') time.sleep(1) cli.log('Loading 1...') time.sleep(1) # pass details cli.defineMapperOne(5001 + (self.num - 1) * 10, self.ip) cli.defineMapperTwo(5002 + (self.num - 1) * 10, self.ip) cli.defineReducer(5003 + (self.num - 1) * 10, self.ip) cli.definePRM(5004 + (self.num - 1) * 10, self.ip) cli.log('Enter commands below. Use ctrl+c to exit.') boo = True while (boo): try: command = raw_input('> ') cli.handleCommand(command.split()) except KeyboardInterrupt: boo = False time.sleep(1) # exiting cli.log('Exiting')
def main(): if len(sys.argv) < 2: print("Serial not specified") return path = sys.argv[1] if not Path(path).exists(): print("Not found:", sys.argv[1]) return cli = CLI(path) sensitive = get_sensitive(cli, 'acceleration') try: data = collect(cli) bias = [ (data[Attitude.ROLL_LEFT] + data[Attitude.ROLL_RIGHT]) / 2, (data[Attitude.PITCH_DOWN] + data[Attitude.PITCH_UP]) / 2, (data[Attitude.FLAT] + data[Attitude.REVERSE]) / 2, ] gain = [ sensitive * sensitive / (data[Attitude.ROLL_RIGHT] - bias[0]), sensitive * sensitive / (data[Attitude.PITCH_UP] - bias[1]), sensitive * sensitive / (data[Attitude.REVERSE] - bias[2]), ] print("bias:", bias) print("gain:", gain) except EOFError: pass cli.close()
def test_migrate(self): CLI().main(['progname', 'migrate']) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_migrate_repo.assert_called_once_with(repo) self.mock_sys_exit.assert_called_once_with(0)
def main(): """ The main entry point of the program. """ cli = CLI(api_key_file=API_KEY_FILE) history = InMemoryHistory() # Build Autocomplete methods = cli.client.context.allowed_api_calls autocomplete = build_autocomplete(cli.client) while True: try: text = prompt('Arsenal >> ', completer=ArsenalCompleter(methods, autocomplete), history=history, auto_suggest=AutoSuggestFromHistory()) if text: text = parse_command(cli.client, text) firethread = FireThread(text, cli) firethread.start() firethread.join() print('') except Reset: cli.client.context = cli.client.get_current_context() methods = cli.client.context.allowed_api_calls autocomplete = build_autocomplete(cli.client) except ShellExit: pass except EOFError: exit_arsenal() except KeyboardInterrupt: exit_arsenal() except Exception as exception: # pylint: disable=broad-except print(exception)
def test_clone(self): src_url = "/origin/url" CLI().main(['progname', 'clone', src_url]) self.mock_clone_repo.assert_called_once_with(src=src_url, dest=self.cwd) self.mock_sys_exit.assert_called_once_with(0)
def __init__(self, config, sgdb=None): Main._check_configuration(config) self.cli = CLI() self.config = config self.log = LOG(self.config.get("log_dir", None)) self.sgdb = sgdb if self.sgdb is None and not self.config.get("new_migration", None): if self.config.get("database_engine") == 'mysql': from mysql import MySQL self.sgdb = MySQL(config) elif self.config.get("database_engine") == 'oracle': from oracle import Oracle self.sgdb = Oracle(config) elif self.config.get("database_engine") == 'mssql': from mssql import MSSQL self.sgdb = MSSQL(config) elif self.config.get("database_engine") == 'postgresql': from postgresql import PostgreSQL self.sgdb = PostgreSQL(config) else: raise Exception("engine not supported '%s'" % self.config.get("database_engine")) self.db_migrate = SimpleDBMigrate(self.config)
def __init__(self, board_size=8, player1_type=HumanPlayer, player2_type=HumanPlayer): self.console = CLI() self.board = Board(board_size) self.manager = Manager() self.p1 = player1_type(Disk.DARK) if issubclass(player1_type, HumanPlayer): self.p1.set_console(self.console) if issubclass(player1_type, SimplePlayer): self.p1.set_manager(self.manager) if issubclass(player1_type, Player02): self.p1.set_minimax_variables(self.manager) self.p2 = player2_type(Disk.LIGHT) if issubclass(player2_type, HumanPlayer): self.p2.set_console(self.console) if issubclass(player2_type, SimplePlayer) or issubclass( player2_type, Player02): self.p2.set_manager(self.manager) if issubclass(player2_type, Player02): self.p2.set_minimax_variables(self.manager) self.current_player = self.p1
def _verify_if_exception_is_invalid_user(self, exception): import pdb pdb.set_trace() #TODO validar como isso funciona no mongodb if 'ORA-01017' in exception.__str__(): try: cli = CLI() cli.msg( '\nPlease inform dba user/password to connect to database "%s"\nUser:' % (self.__host), "END") dba_user = self.std_in.readline().strip() passwd = self.get_pass() conn = self.__driver.connect(dsn=self.__host, user=dba_user, password=passwd) cursor = conn.cursor() cursor.execute("create user %s identified by %s" % (self.__user, self.__passwd)) cursor.execute("grant connect, resource to %s" % (self.__user)) cursor.execute("grant create public synonym to %s" % (self.__user)) cursor.execute("grant drop public synonym to %s" % (self.__user)) cursor.close() conn.close() except Exception, e: raise Exception("check error: %s" % e)
def test_default_viewer(self): CLI().main(['progname', 'view']) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_view_pics.assert_called_once_with(repo, None) self.mock_sys_exit.assert_called_once_with(0)
def test_list_default(self): CLI().main(['progname', 'list']) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_list_pics.assert_called_once_with(repo, 'all') self.mock_sys_exit.assert_called_once_with(0)
def test_add_without_processing(self): files = ['file1', 'file2', 'file3'] CLI().main(['progname', 'add'] + files + ['--noprocess']) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_add_pics.assert_called_once_with(repo, files, False, None) self.mock_sys_exit.assert_called_once_with(0)
def main(args): if len(args) > 0: cli = CLI() cli.run() else: appctxt = AppContext() # 1. Instantiate ApplicationContext exit_code = appctxt.run() # 2. Invoke appctxt.app.exec_() sys.exit(exit_code)
def test_backup_to_many(self): backup_urls = ['/backup1/url', '/backup2/url', '/backup3/url'] CLI().main(['progname', 'backup'] + backup_urls) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_backup_repo.assert_called_once_with(repo, *backup_urls) self.mock_sys_exit.assert_called_once_with(0)
def test_backup(self): backup_url = '/backup/url' CLI().main(['progname', 'backup', backup_url]) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_backup_repo.assert_called_once_with(repo, backup_url) self.mock_sys_exit.assert_called_once_with(0)
def test_merge(self): others = ['repoA', 'repoB', 'repoC'] CLI().main(['progname', 'merge'] + others) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_merge_repos.assert_called_once_with(repo, *others) self.mock_sys_exit.assert_called_once_with(0)
def test_supplied_viewer(self): prog = 'fooview fooviewarg --fooviewopt' CLI().main(['progname', 'view', '--viewer', prog]) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_view_pics.assert_called_once_with(repo, prog) self.mock_sys_exit.assert_called_once_with(0)
def test_remove(self): files = ['file1', 'file2', 'file3'] CLI().main(['progname', 'remove'] + files) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_remove_pics.assert_called_once_with(repo, files) self.mock_sys_exit.assert_called_once_with(0)
def test_check(self): self.mock_check_pics.return_value = ([], []) CLI().main(['progname', 'check']) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_check_pics.assert_called_once_with(repo) self.mock_sys_exit.assert_called_once_with(0)
def test_add(self): files = ['file1', 'file2', 'file3'] CLI().main(['progname', 'add'] + files) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_add_pics.assert_called_once_with(repo, files, True, None) self.mock_sys_exit.assert_called_once_with(0)
def main(): """' Big O(n^3) Initiate the application """ init_data() assign_deliveries() CLI().run()
def testInvalidCommand(self): cli = CLI() # Check for incorrect command with self.assertRaises(ClindException): cli.processCommand("not a command")
def test_add_with_process_recipe(self): files = ['file1', 'file2', 'file3'] recipe = 'FOO.BAR' CLI().main(['progname', 'add'] + files + ['--recipe', recipe]) self.mock_load_repo.assert_called_once_with(self.cwd) repo = self.mock_load_repo.return_value self.mock_add_pics.assert_called_once_with(repo, files, True, recipe) self.mock_sys_exit.assert_called_once_with(0)
def testName(self): cli = CLI() name = cli.processCommand("name") # Check that name command returns a string with space self.assertTrue(isinstance(name, str)) self.assertTrue(" " in name)
def __init__(self, questions, search_engines, storage, maxlength, paste): super(Core, self).__init__(name="core") self.storage = Storage(storage, parent=self) self.messages = MessageDatabase(questions, parent=self) self.search = Search(search_engines, parent=self) self.pingpong = PingPong(parent=self) self.flooding = Flooding(maxlength, paste, parent=self) self.cli = CLI(parent=self) self.log.info("load complete")
def testRoll(self): cli = CLI() # Check roll command for i in range(100): r = cli.processCommand("roll 1d20") self.assertTrue(1 <= r <= 20)
class Config: _config = ConfigParser() _home_dir = expanduser("~") _config_dir = _home_dir + "/.mp_control" _cli = CLI() def _check_config(self): return path.exists(self._config_dir) def create_configs(self): os.mkdir(self._config_dir) with open(self._config_dir + "/config", "w"): pass self._cli.out("Enter the name of project: ", end='') project_name = input() self._cli.out( "Enter the name of project directory (the directory shoult exist in the home directory): ", end='') project_dir = input() self._cli.out( "Enter the link to the BuildTools.jar (example https://example.com/BuildTools.jar): ", end='') build_tool_link = input() self._config["PROJECT_INFO"] = { "name": project_name, "dir": self._home_dir + "/" + project_dir, "build_tool_link": build_tool_link } with open(self._config_dir + "/config", "w") as conf: self._config.write(conf) def get_project_name(self): return self._config["PROJECT_INFO"]["name"] def get_project_dir(self): return self._config["PROJECT_INFO"]["dir"] def get_link_to_buildtool(self): return self._config["PROJECT_INFO"]["build_tool_link"] def init(self, cli): self._cli = cli if not self._check_config(): self.create_configs() self._cli.out("Configs have been created in " + self._config_dir + " directory") self._config.read(self._config_dir + "/config") self._cli.set_history_path(self._config_dir)
def test_parser(self): """Tests the correct behaviour of the parser method: an args string without a required input is passed to the method and the test checks if an exception is raised""" data_handler = DataHandler('') method_handler = MethodHandler(data_handler, '') cli_app = CLI(method_handler) args_exp = {'Ticker': {'Type': 'String', 'Required': 1}, 'StartDate': {'Type': 'Date', 'Required': 1}, 'EndDate': {'Type': 'Date', 'Required': 1}, 'Currency': {'Type': 'String', 'Required': 1}} args_obtained = 'AAPL 2021/01/01 2021/02/14' with self.assertRaises(Exception): res = cli_app.parse_args(args_obtained, args_exp)
def main(args: str): logger = logging.getLogger(__name__) config = CLI().build_config(args) volunteers = v.Volunteers(config).build_volunteers() heuristic = config.heuristic.get_strategy(config.group_size) groups = heuristic.build_groups(volunteers) if config.output: with open("{}/output.json".format(config.output), 'w') as f: f.write(groups) else: logger.warning(groups)
def main(): interface = CLI() commands = (("I", new_image), ("C", clear), ("L", colour_pixel), ("V", draw_vertical_segment), ("H", draw_horizontal_segment), ("F", fill_region), ("S", show), ("X", terminate)) for token, fn in commands: interface.register_command(token, fn) interface.main_loop()