def main(args=None): if args is None: args = sys.argv[1:] init_colorama() cli = CLI() cli.run_trainer()
def init(): os.environ['version'] = get_version() init_colorama() description() build_parser() args = get_args() levels = ['NOTSET', 'WARN', 'INFO', 'DEBUG'] level = os.getenv('LOG_LEVEL') if not level: level = levels[args.log] if args.log else 'NOTSET' # end if if level != 'NOTSET': os.environ['debug_mode'] = 'yes' logging.basicConfig( level=logging.getLevelName(level), format=Fore.CYAN + '%(asctime)s ' + Fore.RED + '[%(levelname)s] ' + Fore.YELLOW + '(%(name)s)\n' + Fore.WHITE + '%(message)s' + Fore.RESET, ) debug_mode(level) # end if if args.suppress: input_suppression() print(args) # end if requests.urllib3.disable_warnings( requests.urllib3.exceptions.InsecureRequestWarning)
def configure_logger(): init_colorama() logger = logging.getLogger() # root logger logger.setLevel(logging.DEBUG) # Formatters datefmt = r"[%m/%d %H:%M:%S]" console_fmt = "%(asctime)s %(levelname)8s | %(message)s (%(filename)s:%(lineno)d)" console_formatter = ColoredFormatter(fmt=console_fmt, datefmt=datefmt) crash_report_fmt = ( "%(asctime)s %(levelname)8s | %(message)s (%(filename)s:%(lineno)d)") crash_report_formatter = logging.Formatter(fmt=crash_report_fmt, datefmt=datefmt) # Filters class FilterGramAddictOnly(logging.Filter): def filter(self, record: LogRecord): return record.name.startswith("GramAddict") # Console handler (limited colored log) console_handler = logging.StreamHandler() console_handler.setLevel(logging.DEBUG) console_handler.setFormatter(console_formatter) console_handler.addFilter(FilterGramAddictOnly()) # Crash report handler (full raw log) global log_stream log_stream = StringIO() crash_report_handler = logging.StreamHandler(log_stream) crash_report_handler.setLevel(logging.DEBUG) crash_report_handler.setFormatter(crash_report_formatter) crash_report_handler.addFilter(FilterGramAddictOnly()) logger.addHandler(console_handler) logger.addHandler(crash_report_handler)
def setUp(self): """ Setups everything needed for the tests. """ init_colorama(autoreset=True) PyFunceble.load_config() StdoutBase.setUp(self) self.green_ascii = "\n".join( [ f"{Fore.GREEN}{x}{Fore.RESET}" for x in PyFunceble.ASCII_PYFUNCEBLE.split("\n") ] ) self.red_ascii = "\n".join( [ f"{Fore.RED}{x}{Fore.RESET}" for x in PyFunceble.ASCII_PYFUNCEBLE.split("\n") ] ) self.home_ascii = "\n".join( [ f"{Fore.YELLOW}{x}{Fore.RESET}" for x in PyFunceble.ASCII_PYFUNCEBLE.split("\n") ] ) self.cli_core = CLI()
def main(): args = parse_cli_args() init_colorama(autoreset=True) ch = logging.StreamHandler() if args.verbose: ch.setLevel(logging.DEBUG) else: ch.setLevel(logging.WARN) ch.setFormatter(LintFormatter()) logging.basicConfig(level=logging.DEBUG, handlers=[ch]) logger.debug('Looking for...') if args.sbml_file_name: logger.debug('\tSBML model: ' + args.sbml_file_name) if args.condition_file_name: logger.debug('\tCondition table: ' + args.condition_file_name) if args.measurement_file_name: logger.debug('\tMeasurement table: ' + args.measurement_file_name) if args.parameter_file_name: logger.debug('\tParameter table: ' + args.parameter_file_name) try: problem = petab.Problem.from_files( sbml_file=args.sbml_file_name, condition_file=args.condition_file_name, measurement_file=args.measurement_file_name, parameter_file=args.parameter_file_name) except FileNotFoundError as e: logger.error(e) sys.exit(1) ret = petab.lint.lint_problem(problem) sys.exit(ret)
def main(): init_colorama() os.environ['version'] = get_version() description() build_parser() args = get_args() if args.log: os.environ['debug_mode'] = 'true' levels = [None, logging.WARN, logging.INFO, logging.DEBUG] logging.basicConfig(level=levels[args.log]) debug_mode(args.log) print(args) requests.urllib3.disable_warnings( requests.urllib3.exceptions.InsecureRequestWarning) try: if args.test: run_tests() else: start_app(spiders) except Exception as err: if args.log == 3: raise err
def main(source_path, nl, bare): """ Visualize Python token stream produced by tokenize module. """ init_colorama() with open(source_path, "r", newline="") as source: display_tokens(source.read(), show_newlines=nl, bare=bare)
def __init__(self, timestamp, level, source, event, message): self._timestamp = timestamp self._level = level self._source = source self._event = event self._message = message self.__validate_log() init_colorama()
def main(): """Run PEtab validator""" args = parse_cli_args() init_colorama(autoreset=True) ch = logging.StreamHandler() if args.verbose: ch.setLevel(logging.DEBUG) else: ch.setLevel(logging.WARN) ch.setFormatter(LintFormatter()) logging.basicConfig(level=logging.DEBUG, handlers=[ch]) if args.yaml_file_name: from petab.yaml import validate from jsonschema.exceptions import ValidationError try: validate(args.yaml_file_name) except ValidationError as e: logger.error("Provided YAML file does not adhere to PEtab " f"schema: {e}") sys.exit(1) if petab.is_composite_problem(args.yaml_file_name): # TODO: further checking: # https://github.com/ICB-DCM/PEtab/issues/191 # problem = petab.CompositeProblem.from_yaml(args.yaml_file_name) return problem = petab.Problem.from_yaml(args.yaml_file_name) else: logger.debug('Looking for...') if args.sbml_file_name: logger.debug(f'\tSBML model: {args.sbml_file_name}') if args.condition_file_name: logger.debug(f'\tCondition table: {args.condition_file_name}') if args.observable_file_name: logger.debug(f'\tObservable table: {args.observable_file_name}') if args.measurement_file_name: logger.debug(f'\tMeasurement table: {args.measurement_file_name}') if args.parameter_file_name: logger.debug(f'\tParameter table: {args.parameter_file_name}') try: problem = petab.Problem.from_files( sbml_file=args.sbml_file_name, condition_file=args.condition_file_name, measurement_file=args.measurement_file_name, parameter_file=args.parameter_file_name, observable_files=args.observable_file_name) except FileNotFoundError as e: logger.error(e) sys.exit(1) ret = petab.lint.lint_problem(problem) sys.exit(ret)
def main(): init_colorama() try: return run(sys.argv) except EspHomePreprocessorError as e: error(e) return 1 except KeyboardInterrupt: return 1
def setup_logging(self): if self.o.no_color: init_colorama(strip=True) log.setLevel(logging.DEBUG if self.o.verbose else logging.INFO) ch = logging.StreamHandler(sys.stdout) ch.setLevel(logging.DEBUG if self.o.verbose else logging.INFO) if not self.o.no_color: ch.setFormatter(util.ColorFormatter('%(levelname)s %(message)s')) else: ch.setFormatter(logging.Formatter('%(levelname)s %(message)s')) log.addHandler(ch)
def main(): """Generate HDF5 file based on CLI options""" init_colorama(autoreset=True) args = parse_cli_args() petab_problem = petab.Problem.from_yaml(args.petab_yaml) amici_model = get_amici_model(model_name=args.model_name, model_dir=args.model_dir) h5gen = HDF5DataGenerator(petab_problem=petab_problem, amici_model=amici_model) h5gen.generate_file(args.hdf5_file_name)
def configure(): init_colorama() mode = sys.argv[1].lower() if len(sys.argv) > 1 else None if mode == '-v' or mode == '--verbose': os.environ['debug_mode'] = 'true' print(Fore.RED, Icons.SOUND, 'IN VERBOSE MODE', Fore.RESET) print('-' * 60) logging.basicConfig(level=logging.DEBUG) # end if requests.urllib3.disable_warnings( requests.urllib3.exceptions.InsecureRequestWarning)
def print_updates_to_console(updates: List["Update"]) -> None: init_colorama() for update in updates: print(f"{Style.BRIGHT}[{update.title}]{Style.RESET_ALL}\n") for image in update.images: print( MAGIC_IMAGE_LINE.format( encoded_image=base64.b64encode(image).decode("ascii") ) ) print() if update.description: print(f"{Fore.LIGHTGREEN_EX}{update.description}{Style.RESET_ALL}\n")
def main(): args = parse_args() if args.verbosity == 3: init_logging(logging.DEBUG) elif args.verbosity == 2: init_logging(logging.INFO) elif args.verbosity == 1: init_logging(logging.WARNING) elif args.verbosity == 0: init_logging(logging.ERROR) logger.debug(f"args: {args}") init_colorama(strip=not args.force_colors) if args.circus_cmd == "status": print( handle_status( circus_args=args.circus_args, dry_run=args.dry_run, allow_missing_systemd_unit=args.allow_missing_systemd_unit, verbose=args.verbosity > 1, circusctl_path=args.circusctl_path, get_systemd_status=args.get_systemd_status, short=args.short, )) else: circus_config_path = Path("/", "users", USER, "circus", HOST, "circus.ini") circusctl_cmd = _circus( circus_config_path, circus_args=[args.circus_cmd, *args.circus_args], dry_run=args.dry_run, circusctl_path=args.circusctl_path, ) if args.verbosity > 1: circus_cmd_str = f"$ {shlex.join(circusctl_cmd.args)}" else: circus_cmd_str = args.circus_cmd if circusctl_cmd.returncode == 0: print( f"{Fore.GREEN}{USER}@{HOST}: Circus command '{circus_cmd_str}': SUCCESS{Style.RESET_ALL}" ) for line in circusctl_cmd.stdout.splitlines(): print(f" {line}") else: print( f"{Fore.RED}{USER}@{HOST}: Circus command '{circus_cmd_str}': FAILED{Style.RESET_ALL}" ) print(circusctl_cmd.stderr, file=sys.stderr)
def main(): """Generate HDF5 file based on CLI options""" init_colorama(autoreset=True) coloredlogs.DEFAULT_LEVEL_STYLES['debug'] = dict(color='white', faint='true') coloredlogs.install(level='DEBUG', logger=logger) args = parse_cli_args() petab_problem = petab.Problem.from_yaml(args.petab_yaml) amici_model = get_amici_model(model_name=args.model_name, model_dir=args.model_dir) h5gen = HDF5DataGenerator(petab_problem=petab_problem, amici_model=amici_model) h5gen.generate_file(args.hdf5_file_name)
def run() -> None: init_colorama() try: opts = load_options(HELP) if opts['--version']: print(VERSION) return if opts['--help']: print(HELP) return prefs = load_prefs(PREFS_FILE) interpolated_opts = interpolate_variables(opts, prefs) sesh = get_session(interpolated_opts, prefs, PREFS_FILE) resp = send_request(sesh, prefs, interpolated_opts, PREFS_FILE) print_response(resp, prefs) except APIBuddyException as err: exit_with_exception(err)
def main(): args = parse_cli_args() init_colorama(autoreset=True) # First check for valid PEtab pp = petab.Problem.from_files(sbml_file=args.sbml_file_name, condition_file=args.condition_file_name, measurement_file=args.measurement_file_name, parameter_file=args.parameter_file_name) petab.lint_problem(pp) import_model(args.sbml_file_name, args.condition_file_name, args.measurement_file_name, model_output_dir=args.model_output_dir, compile=args.compile, verbose=True)
def configure_logger(debug, username): global g_session_id global g_log_file_name global g_logs_dir global g_file_handler global g_log_file_updated console_level = logging.DEBUG if debug else logging.INFO g_session_id = uuid4() g_logs_dir = "logs" if username: g_log_file_name = f"{username}.log" g_log_file_updated = True else: g_log_file_name = f"{g_session_id}.log" g_log_file_updated = False init_colorama() # Root logger root_logger = logging.getLogger() root_logger.setLevel(logging.DEBUG) # Console logger (limited but colored log) console_handler = logging.StreamHandler() console_handler.setLevel(console_level) console_handler.setFormatter( ColoredFormatter( fmt="%(asctime)s %(levelname)8s | %(message)s", datefmt="[%m/%d %H:%M:%S]" ) ) console_handler.addFilter(LoggerFilterGramAddictOnly()) root_logger.addHandler(console_handler) # File logger (full raw log) if not os.path.exists(g_logs_dir): os.makedirs(g_logs_dir) g_file_handler = create_log_file_handler(f"{g_logs_dir}/{g_log_file_name}") root_logger.addHandler(g_file_handler) init_logger = logging.getLogger(__name__) init_logger.debug(f"Initial log file: {g_logs_dir}/{g_log_file_name}")
def main(): parser = ArgumentParser() parser.add_argument('--name', type=str, default='') parser.add_argument('--bots', type=str, default='NRR') parser.add_argument('--no-color', action='store_true', default=False) args = parser.parse_args() global COLORING COLORING = not args.no_color if COLORING: init_colorama() bots = args.bots name = args.name if not name: name = io.dialog('Enter your name', lambda n: n.strip() != '') game = Game(Deck(standard_chars()), Deck(simple_districts())) game_controller = GameController(game) assert 1 <= len(bots) <= 3 assert all(b in 'NR' for b in bots) player = game.add_player(name) game_controller.set_player_controller(player, TermPlayerController()) game_controller.add_listener(TermGamePlayListener(player, game)) bot_factory = {'R': RandomBotController, 'N': NaiveBotController} for i, b in enumerate(bots): bot = game.add_player('bot{}'.format(i + 1)) game_controller.set_player_controller(bot, bot_factory[b]()) while not game_controller.game_over: game_controller.play() print('\n----------------------\nGame over!\n') for player in game.players: print('{plr} scored {score}'.format(plr=player.name, score=rules.score(player, game))) print('Winner is {plr}'.format(plr=game_controller.winner.name))
def __init__(self): init_colorama() self.talking='setup manager' self.step_title('Welcome to the PyOS software installer') check=self.ask('Do you want to proceed ? (y/n)') if check=='y': try: import panda3d self.step_title('The panda3d library is already installed') except: self.step_title('Oops, it looks like the panda3d library is not available on your machine') check2=self.ask('Do you want to install it ? Doing so will allow you to run the code directly from the python IDE (y/n)') check1=self.ask("Do you want to download the last stable release ? It is recommended to do so if you're not a developer (y/n)") if check1=='y': self.step_title('Download has started...') self.step_title('Please be patient, the download speed depends on your internet connection.\nFile size is approximately 500MB') urllib.request.urlretrieve(URL,CWD+'\\downloads\\update.zip') ''' zipObject=ZipFile(CWD+'\\downloads\\update.zip','r') zipObject.extractall(path=CWD+'\\downloads\\update') ''' else: sys.exit(0)
def download(nthreads=20, killer=True, status_server=True, discover_only=False): """ Args: nthreads (int, optional): number of threads to use. Defaults to 20. killer (bool, optional): if True, an extra thread will be launched to detect key pressings, shuch as K for kill the app. Defaults to True. status_server (bool, optional): if true, a http server will be opened in port 80 to show the status of each thread. Defaults to True. discover_only (bool, optional): if true, it will only discover the subjects, without downloading anything. Defaults to False. """ logger = logging.getLogger(__name__) logger.info( "Launching notify(nthreads=%r, killer=%s, status_server=%s, discover_only=%s)", nthreads, killer, status_server, discover_only, ) init_colorama() queue = Queue() threads = start_workers(queue, nthreads, killer=killer) if status_server: runserver(queue, threads) with Connection(): find_subjects(queue, discover_only=discover_only) logger.debug("Waiting for queue to empty") queue.join()
def start(root_folder=None, nthreads=None, timeout=None, no_killer=False): """Starts the app. Args: root_folder (str): folder where files will be downloaded. nthreads (int): number of threads to start. timeout (int): number of seconds before discarting TCP connection. no_killer (bool): desactivate Killer thread. """ init_colorama() if not nthreads: nthreads = 50 if root_folder: Options.set_root_folder(root_folder) if timeout: Options.set_timeout(timeout) initial_time = time.time() main_logger = logging.getLogger(__name__) main_logger.info('STARTING APP') main_logger.debug('Starting downloader') downloader = Downloader() main_logger.debug('Starting queue') queue = Queue() main_logger.debug('Launching subjects finder') find_subjects(downloader, queue, nthreads, no_killer) main_logger.debug('Waiting for queue to empty') queue.join() final_time = time.time() - initial_time main_logger.info('VCD executed in %s', seconds_to_str(final_time))
' {text}\n', Style.RESET_ALL ]) } #: The maximum length of a response displayed in a debug message DEBUG_MAX_TEXT_LENGTH = 100 if os.name == 'nt' and run_from_ipython(): # IPython stops working properly when it loses control of # `stdout` on Windows. In this case we won't enable Windows # color support and we'll strip out all colors from the debug # messages. init_colorama(wrap=False) else: init_colorama() class Client(object): """Wrapper around the most basic methods of the requests library.""" def __init__(self, debug=False, cache=None, **kwargs): self.headers = Bunch() self.debug = debug self.cache = cache if cache else DictCache() self.cache = CacheWrapper(self.cache) self.session = requests.session() self._last_request_time = None self.defaults = kwargs
#! /usr/bin/env python3 import logging from flask.ext.script import Manager, Command from App.App import create_app from commands.get_deps import GetDeps from commands.dbutils import InitDB, UpdateDB, FixFont from commands.run_tests import RunTests from colorama import init as init_colorama from colorama import Fore, Back, Style init_colorama(autoreset=True) from flask.ext.assets import ManageAssets manager = Manager(create_app) manager.add_option('-c', '--app-config', dest='config', required=False) manager.add_command('get_deps', GetDeps()) manager.add_command("assets", ManageAssets()) manager.add_command('initdb', InitDB()) manager.add_command('updatedb', UpdateDB()) manager.add_command('fixfont', FixFont()) manager.add_command('test', RunTests) if __name__ == '__main__': log_fmt = '[notMyType][%(levelname)s] %(lineno)d in %(funcName)s - %(message)s' logging.basicConfig(format=log_fmt, level=logging.DEBUG) manager.run()
async def main(args: Optional[List[str]] = None) -> int: """Main entry point for `bscan`'s command-line interface. Args: args: Custom arguments to override ``sys.argv``. Returns: The exit code of the program. """ try: init_colorama() if not good_py_version(): print_w_d1('Running with Python version ', py_version_str(), 'but this program is only tested with Python 3.6') opts = get_parsed_args(args) print_i_d1('Initializing configuration from command-line arguments') mc = opts.max_concurrency try: mc = (20 if mc is None else int(mc)) if mc < 1: raise ValueError except ValueError: raise BscanConfigError( 'Invalid `--max-concurrency` positive integer value ' 'received: ' + str(mc)) async with Sublemon(max_concurrency=mc) as subl: await write_db_value('sublemon', subl) await init_config(opts) print_color_info() if not opts.targets: print_e_d1('No targets specified; use `--help` to figure ' 'out what you\'re doing') return 1 # TODO: create a full list of targets from network address and # --ping-sweep filtering targets = [] _target_set: Set[str] = set() for candidate in opts.targets: if candidate in _target_set: print_w_d1( 'Target ', candidate, ' has already been added as a ' 'target; skipping another attempted addition') continue elif is_valid_ip_host_addr(candidate): pass elif is_valid_hostname(candidate): pass elif is_valid_ip_net_addr(candidate): print_w_d1( 'Network scanning not yet supported; ' 'skipping network: ', candidate) continue else: print_e_d1('Unable to parse target ', candidate, ', skipping it') continue try: create_dir_skeleton(candidate) except BscanForceSkipTarget as e: print_e_d1(e.message) print_e_d1(candidate, ': skipping this target') continue targets.append(candidate) _target_set.add(candidate) if not targets: print_e_d1('No valid targets specified') return 1 print_i_d1('Kicking off scans of ', len(targets), ' targets') tasks = [scan_target(target) for target in targets] if get_db_value('status-interval') > 0: tasks.append(status_update_poller()) await asyncio.gather(*tasks) print_i_d1('Completed execution') return 0 except BscanConfigError as e: print_e_d1('Configuration error: ', e.message) return 1 except BscanForceSilentExit as e: return 1 except BscanInternalError as e: print_e_d1('Internal error: ', e.message) return 1 except BscanSubprocessError as e: print_e_d1('Error handling subprocess: ', e.message) return 1 except BscanError as e: print_e_d1('This should not be reached!') return 1 except Exception as e: print_e_d1('Received unexpected exception; re-raising it.', file=sys.stderr) raise e
from colorama import Fore, Back, Style from colorama import init as init_colorama init_colorama() stopState = False prom = "dogrex> " inpt = "" print("Welcome to DogRex, the dog simulator!") def starting(): print("What thing do you want to make?") print("\n1. New game\n2. Exit\n") return input(prom) if __name__ == "__main__": try: while stopState == False: if starting() == 1: print( "For now, this game is in early access and you can't play for now..." ) exit() else: print("Goodbye!") exit() except KeyboardInterrupt: print() print("Goodbye!")
def main(): init_colorama() try: ExampleApp().start() finally: deinit_colorama()
#! /usr/bin/env python3 import logging from flask.ext.script import Manager, Command from App.App import create_app from commands.get_deps import GetDeps from commands.dbutils import InitDB, UpdateDB, FixFont from commands.run_tests import RunTests from colorama import init as init_colorama from colorama import Fore, Back, Style init_colorama(autoreset=True) from flask.ext.assets import ManageAssets manager = Manager(create_app) manager.add_option('-c', '--app-config', dest='config', required=False) manager.add_command('get_deps', GetDeps()) manager.add_command("assets", ManageAssets()) manager.add_command('initdb', InitDB()) manager.add_command('updatedb', UpdateDB()) manager.add_command('fixfont', FixFont()) manager.add_command('test', RunTests) if __name__ == '__main__': log_fmt = '[notMyType][%(levelname)s] %(lineno)d in %(funcName)s - %(message)s' logging.basicConfig(format=log_fmt, level=logging.DEBUG) manager.run()
def main(argv=None): init_colorama() global DEBUG if argv is None: argv = sys.argv parser = OptionParser() parser.set_defaults(action=None) parser.add_option("--quiet", "-q", dest="debug", action="store_false", default=True, help="Suppress nice human-readable reporting") (options, urls) = parser.parse_args(args=argv) DEBUG = options.debug urls[:1] = [] debug("Your input files are: ") for url in urls: debug("\t%s" % url) for url in urls: debug(red("-" * len("URL: %s"%url))) debug(red("URL: %s" % url)) debug(red("-" * len("URL: %s"%url))) try: d = get_distiller(url) except: print "Don't know how to handle URL: %s" % url continue for doc in d.docs: if doc is None: continue debug(green("Adding to index: %(url)s" % doc)) # Depending on the backend, the blob will either be str # or unicode: # Gollum: unicode # RT: str # Map: str # Provsys: str # # We need to test for this because blindly encode()ing # the blob will result in errors if it's already a # UTF8 str. trimmed_blob = doc['blob'][:400] if type(trimmed_blob) is str: debug(blue("400 chars of blob: {0}".format(trimmed_blob))) else: # unicode debug(blue(u"400 chars of blob: {0}".format(trimmed_blob))) add_to_index(doc) debug(green("Success!")) debug("") debug(red("-------")) debug(red("Now reprinting the document we just indexed")) document_just_added = get_from_index(doc['url'])['_source'] for key in sorted(document_just_added): if not isinstance(document_just_added[key], (str,unicode)): document_just_added[key] = str(document_just_added[key]) debug(green(key.capitalize())) debug(u"\t{0}".format(document_just_added[key][:1000]).encode('utf8')) debug("") return 0
logger.debug('Running script.') def err(ex): logger.warn(str(ex), exc_info=debug) script.on('line.error', err) script.on('action.error', err) script.dry_run = dry_run try: script.run() except StorageError as ex: if debug: logger.exception('Storage error running script: %s' % ex.args[0]) else: click.echo('Storage error running script: %s' % ex.args[0]) raise SystemExit(1) except (ScriptError, FixtureError) as ex: if debug: logger.exception('Runtime error with script: %s' % ex.args[0]) else: click.echo('Runtime error with script: %s' % ex.args[0]) raise SystemExit(1) # Strip colors if stdout is redirected init_colorama(strip=not sys.stdout.isatty())
def main(): init_colorama() try: ExampleApp().start() finally: deinit_colorama()
def main(args=None): """Main entry point for `donatello`'s command-line interface. Args: args (List[str]): Custom arguments if you wish to override sys.argv. Returns: int: The exit code of the program. """ try: init_colorama() opts = get_parsed_args(args) if opts.bad_chars is not None: bad_chars = _parse_bytes(opts.bad_chars, check_dups=True) else: bad_chars = b'' bad_chars_as_ints = tuple(int(bc) for bc in bad_chars) if opts.max_factors is not None: max_factors = _parse_max_factors(opts.max_factors) else: max_factors = 2 if opts.ops is not None: ops = _parse_ops(opts.ops) else: ops = IMPLEMENTED_OPS if opts.command not in ( 'factor', 'encode', ): raise DonatelloConfigurationError( 'must specify either `factor` or `encode`; `' + opts.command + '` is invalid') if opts.target == '-': # TODO: https://docs.python.org/3/library/fileinput.html pass else: target = opts.target if opts.command == 'factor': value = _parse_target_hex(target) print_i('Attempting to factor target value ', format_dword(value)) for num_factors in range(2, max_factors + 1): factors = factor_by_byte(value, bad_chars_as_ints, usable_ops=ops, num_factors=num_factors) if factors is not None: print_i('Found factorization!') res = [' 0x00000000'] for f in factors: res.append('{0: <3}'.format(f.operator) + ' ' + format_dword(f.operand)) print('\n'.join(res)) break else: print_e('Unable to find any factors') elif opts.command == 'encode': payload = _parse_bytes(target) print_i('Attempting to encode payload...') asm = encode_x86_32(payload, bad_chars, max_factors=max_factors) print_i('Successfully encoded payload!') print(asm) return 0 except (DonatelloCannotEncodeError, DonatelloNoPossibleNopsError) as e: print_e('Failed to factor/encode the specified target: ', e) return 1 except DonatelloConfigurationError as e: print_e('Configuration error: ', e) return 1 except DonatelloNoPresentBadCharactersError: print_e('No bad characters present in the specified payload; ', 'use the -f/--force flag to bypass this check') return 1 except DonatelloError as e: print_e('This should not be reached! See below for error.') print_e(e) return 1 except Exception as e: print_e('Received unexpected exception; re-raising it.') raise e
for subdir in subdirs: terminfo_path = os.path.join(terminfo_dir, subdir, term) try: f = open(terminfo_path, 'rb') break except IOError as e: if e.errno != errno.ENOENT: raise return f if os.name == 'nt': from colorama import init as init_colorama, AnsiToWin32 init_colorama(wrap=False) STREAM = AnsiToWin32(sys.stderr).stream SUPPORTS_COLOR = True else: if os.getenv('FORCE_COLOR', None) == '1': SUPPORTS_COLOR = True else: f = get_terminfo_file() if f is not None: with f: # f is a valid terminfo; seek and read! magic_number = struct.unpack('<h', f.read(2))[0] if magic_number == 0x11A: # the opened terminfo file is valid. offset = 2 + 10 # magic number + size section (the next thing we read from)
from colorama import Fore, init as init_colorama import os EGGMONKEY = Fore.RED + "EGGMONKEY: " + Fore.RESET EXTERNAL = Fore.BLUE + "RUNNING: " + Fore.RESET init_colorama() class Error(Exception): """ EggMonkey runtime error """ def find_file(path, name): for root, _dirs, names in os.walk(path): if name in names: return os.path.join(root, name) raise ValueError("File not found: %s in %s" % (name, path)) def which(program): """Check if an executable exists""" def is_exe(fpath): return os.path.exists(fpath) and os.access(fpath, os.X_OK) fpath, _fname = os.path.split(program) if fpath: if is_exe(program): return program