def print_response(txt): response_json = json.loads(txt) colorful_json = highlight(json.dumps(response_json, indent=4), JsonLexer(), TerminalFormatter()) print(colorful_json) #pprint.pprint(response_json) print('Chain length: ' + str(len(response_json)))
def androarsc_main(arscobj, outp=None, package=None, typ=None, locale=None): package = package or arscobj.get_packages_names()[0] ttype = typ or "public" locale = locale or '\x00\x00' # TODO: be able to dump all locales of a specific type # TODO: be able to recreate the structure of files when developing, eg a # res folder with all the XML files if not hasattr(arscobj, "get_{}_resources".format(ttype)): print("No decoder found for type: '{}'! Please open a bug report.". format(ttype), file=sys.stderr) sys.exit(1) x = getattr(arscobj, "get_" + ttype + "_resources")(package, locale) buff = etree.tostring(etree.fromstring(x), pretty_print=True, encoding="UTF-8") if outp: with open(outp, "wb") as fd: fd.write(buff) else: sys.stdout.write( highlight(buff.decode("UTF-8"), get_lexer_by_name("xml"), TerminalFormatter()))
def _pstr_codeblock(self, ip: int) -> Optional[List[PrettyString]]: """ Example: 0x40115e: mov rax, qword ptr [rbp - 0x20] 0x401162: mov rax, qword ptr [rax] 0x401165: mov rsi, rax 0x401168: lea rdi, [rip + 0xe95] 0x40116f: mov eax, 0 0x401174: call 0x401040 :param int ip: Address of the start of the block (typically the instruction pointer, thus ip) :return Optional[str]: If a code block could be generated returns the colored assembly, else None """ try: block = self.state.project.factory.block(ip, backup_state=self.state) code = self._disassembler.block_disass(block, self) if not Color.disable_colors: return highlight(code, NasmLexer(), TerminalFormatter()) else: return code except SimEngineError as e: l.info("Got exception %s, returning None" % e) return None
def _format_output(code, args): """ Zwroc pokolorowany kod. Procedura: 1. Stworz najpierw lexera (wpierw na podstawie tagow, jezelie sie nie da to go zgaduje) 2. Pokoloruj kod lexerem :param code: :param args: :return: """ if not args['color']: return code lexer = None # try to find a lexer using the StackOverflow tags # or the query arguments for keyword in args['query'].split() + args['tags']: try: lexer = get_lexer_by_name(keyword) break except ClassNotFound: pass # no lexer found above, use the guesser if not lexer: try: lexer = guess_lexer(code) except ClassNotFound: return code return highlight(code, lexer, TerminalFormatter(bg='dark'))
def _highlight(self, source: str) -> str: """Highlight the given source code if we have markup support.""" from _pytest.config.exceptions import UsageError if not self.hasmarkup or not self.code_highlight: return source try: from pygments.formatters.terminal import TerminalFormatter from pygments.lexers.python import PythonLexer from pygments import highlight import pygments.util except ImportError: return source else: try: highlighted: str = highlight( source, PythonLexer(), TerminalFormatter( bg=os.getenv("PYTEST_THEME_MODE", "dark"), style=os.getenv("PYTEST_THEME"), ), ) return highlighted except pygments.util.ClassNotFound: raise UsageError( "PYTEST_THEME environment variable had an invalid value: '{}'. " "Only valid pygment styles are allowed.".format( os.getenv("PYTEST_THEME"))) except pygments.util.OptionError: raise UsageError( "PYTEST_THEME_MODE environment variable had an invalid value: '{}'. " "The only allowed values are 'dark' and 'light'.".format( os.getenv("PYTEST_THEME_MODE")))
def get_terminal_formatter(**opts): """Returns the best formatter available in the current terminal.""" if '256' in os.environ.get('TERM', ''): formatter = Terminal256Formatter(**opts) else: formatter = TerminalFormatter(**opts) return formatter
def _setup_highlight(self): from pygments import highlight from pygments.lexers.python import PythonTracebackLexer from pygments.formatters.terminal import TerminalFormatter return partial(highlight, lexer=PythonTracebackLexer(), formatter=TerminalFormatter())
def output_why_test_failed(self, test_result: TestResult): err = test_result.error if isinstance(err, TestFailure): src_lines, line_num = inspect.getsourcelines(test_result.test.fn) # TODO: Only include lines up to where the failure occurs if src_lines[-1].strip() == "": src_lines = src_lines[:-1] gutter_width = len(str(len(src_lines) + line_num)) def gutter(i): offset_line_num = i + line_num rv = f"{str(offset_line_num):>{gutter_width}}" if offset_line_num == err.error_line: return colored(f"{rv} ! ", color="red") else: return lightblack(f"{rv} | ") if err.operator in Comparison: src = "".join(src_lines) src = highlight(src, PythonLexer(), TerminalFormatter()) src = f"".join( [gutter(i) + l for i, l in enumerate(src.splitlines(keepends=True))] ) print(indent(src, DOUBLE_INDENT)) if err.operator == Comparison.Equals: self.print_failure_equals(err) else: self.print_traceback(err) print(Style.RESET_ALL)
def __init__(self, env: Environment, explicit_json=False, color_scheme=DEFAULT_STYLE, **kwargs): super().__init__(**kwargs) if not env.colors: self.enabled = False return use_auto_style = color_scheme == AUTO_STYLE has_256_colors = env.colors == 256 if use_auto_style or not has_256_colors: http_lexer = PygmentsHttpLexer() body_formatter = header_formatter = TerminalFormatter() precise = False else: from ..lexers.http import SimplifiedHTTPLexer header_formatter, body_formatter, precise = self.get_formatters( color_scheme) http_lexer = SimplifiedHTTPLexer(precise=precise) self.explicit_json = explicit_json # --json self.header_formatter = header_formatter self.body_formatter = body_formatter self.http_lexer = http_lexer self.metadata_lexer = MetadataLexer(precise=precise)
def __init__(self, env: Environment, explicit_json=False, color_scheme=DEFAULT_STYLE, **kwargs): super().__init__(**kwargs) if not env.colors: self.enabled = False return use_auto_style = color_scheme == AUTO_STYLE has_256_colors = env.colors == 256 if use_auto_style or not has_256_colors: http_lexer = PygmentsHttpLexer() formatter = TerminalFormatter() else: from ..lexers.http import SimplifiedHTTPLexer http_lexer = SimplifiedHTTPLexer() formatter = Terminal256Formatter( style=self.get_style_class(color_scheme)) self.explicit_json = explicit_json # --json self.formatter = formatter self.http_lexer = http_lexer
def androaxml_main(inp, outp=None, resource=None): ret_type = androconf.is_android(inp) if ret_type == "APK": a = apk.APK(inp) if resource: if resource not in a.files: print("The APK does not contain a file called '{}'".format( resource), file=sys.stderr) sys.exit(1) axml = AXMLPrinter(a.get_file(resource)).get_xml_obj() else: axml = a.get_android_manifest_xml() elif ".xml" in inp: axml = AXMLPrinter(read(inp)).get_xml_obj() else: print("Unknown file type") sys.exit(1) buff = etree.tostring(axml, pretty_print=True, encoding="utf-8") if outp: with open(outp, "wb") as fd: fd.write(buff) else: sys.stdout.write( highlight(buff.decode("UTF-8"), get_lexer_by_name("xml"), TerminalFormatter()))
def colored_source(self) -> str: source = pygments.highlight( code=self.source, lexer=PythonLexer(), formatter=TerminalFormatter(), ) return source.rstrip()
def print_exception(e: Exception): if isinstance(e, ASSyntaxError): click.echo(f'{click.style("Syntax error:", fg="red", bold=True)} {e}') else: click.echo(f'{click.style("Runtime error:", fg="red", bold=True)}') click.echo( highlight(traceback.format_exc(), Python3TracebackLexer(), TerminalFormatter()))
def _pretty_format_sql(text: str): import pygments from pygments.formatters.terminal import TerminalFormatter from pygments.lexers.sql import SqlLexer text = pygments.highlight(code=text, formatter=TerminalFormatter(), lexer=SqlLexer()).rstrip() return text
def highlight_terminal(code, language): if not has_pygments: return code if not _colorable_terminal(): return code return pygments_highlight(code, get_lexer_by_name(language), TerminalFormatter())
def jprint(obj, colors=True): formatted_json = json.dumps(obj, sort_keys=True, indent=4) if colors: colorful_json = highlight(formatted_json, JsonLexer(), TerminalFormatter()) print(colorful_json) else: print(formatted_json)
def pretty_print_query(query): """ Converts your SQLALchemy query object into pretty SQL Code """ parsed_query = sqlparse.format(str(query), reindent=True) lexer = SqlLexer() formatter = TerminalFormatter(bg="dark") print(pygments.highlight(parsed_query, lexer, formatter))
def responseParser(response): if response.status_code != 200: print("Failed") print(response.headers) print(response.status_code) print(response) else: json_str = json.dumps(response.json(), indent=2) print(highlight(json_str, JsonLexer(), TerminalFormatter()))
def __init__(self, j, *args, **kwargs): super(FormattedJsonList, self).__init__(*args, **kwargs) self.extend(j) formatted_json = json.dumps(self, indent=4, sort_keys=True, cls=DateTimeEncoder) self.colorful_json = highlight(formatted_json.encode("UTF-8"), JsonLexer(), TerminalFormatter())
def var_2_cool_json(data): """ :param data: :return: """ output = json.dumps(data, indent=2) return highlight(output, JsonLexer(), TerminalFormatter())
def print_response(txt): response_json = txt.json() #subdomains = response_json['domain_siblings'] subdomains = {'domain_siblings': response_json['domain_siblings']} # print(type(subdomains)) # print(type(response_json)) # print(type(json.dumps(subdomains, indent=4))) colorful_json = highlight(json.dumps(subdomains, indent=4), JsonLexer(), TerminalFormatter()) print(colorful_json)
def color_sql(code): """ Beautify and colorify SQL snippet. @param code: string @return: string """ lexer = get_lexer_by_name("sql", stripall=True) sql = sqlparse.format(code, reindent=True, keyword_case='upper') return highlight(sql, lexer, TerminalFormatter())
def show_config(args): """Show current application configuration""" with io.StringIO() as output: conf.write(output) code = output.getvalue() if should_use_colors(args): code = pygments.highlight(code=code, formatter=TerminalFormatter(), lexer=IniLexer()) print(code)
def dump_object(data, format: str = "json"): if type(data).__name__ == "APIError": return bcolors.FAIL + str(data) + bcolors.ENDC if format == "json": return json.dumps(data) elif format == "yaml": return pygments.highlight(yaml.safe_dump(data), YamlLexer(), TerminalFormatter()) else: return "Unknown output format"
def block_code(self, code, lang=None): """Rendering block level code. ``pre > code``. :param code: text content of the code block. :param lang: language of the given code. """ lexer = get_lexer_by_name(lang) if lang else guess_lexer(code) hl = highlight(code, lexer, TerminalFormatter(bg='dark', linenos=False)) return f'\n{hl}\n'
def _get_color_code(color, language, code): format_color_code = code if color: lexter = get_lexer_by_name(language) format_color_code = highlight(code, lexter, TerminalFormatter(bg='dark')) if language: format_color_code = _format_codes(language, format_color_code) return format_color_code
def colorize_decompiled_method(method): """ Args: method: Prints highlighted decompiled method """ print( highlight(method, formatter=TerminalFormatter(bg="dark"), lexer=JavaLexer()))
def colorize_disas_method(method): """ Args: method: Prints highlighted diassembled method """ print( highlight(method, formatter=TerminalFormatter(bg="dark"), lexer=SmaliLexer()))
def terminal(self): """ Return a Terminal-friendly (with ANSI color sequences) representation of the snippet. """ formatter = TerminalFormatter( linenos=True, colorscheme=None, linenostart=self._start_line, ) return pygments.format(self.src_tokens(), formatter)
def pretty_json(obj: Union[str, dict, list]) -> None: """ Print JSON with indentation and colours :param obj: the object to print - can be a dict or a string """ if isinstance(obj, str): try: obj = json.loads(obj) except ValueError: raise ClientException("`obj` is not a json string") json_str = json.dumps(obj, sort_keys=True, indent=2) print(highlight(json_str, JsonLexer(), TerminalFormatter()))
def main_inner(popts, args, usage): opts = {} O_opts = [] P_opts = [] F_opts = [] for opt, arg in popts: if opt == '-O': O_opts.append(arg) elif opt == '-P': P_opts.append(arg) elif opt == '-F': F_opts.append(arg) opts[opt] = arg if opts.pop('-h', None) is not None: print(usage) return 0 if opts.pop('-V', None) is not None: print('Pygments version %s, (c) 2006-2017 by Georg Brandl.' % __version__) return 0 # handle ``pygmentize -L`` L_opt = opts.pop('-L', None) if L_opt is not None: if opts: print(usage, file=sys.stderr) return 2 # print version main(['', '-V']) if not args: args = ['lexer', 'formatter', 'filter', 'style'] for arg in args: _print_list(arg.rstrip('s')) return 0 # handle ``pygmentize -H`` H_opt = opts.pop('-H', None) if H_opt is not None: if opts or len(args) != 2: print(usage, file=sys.stderr) return 2 what, name = args # pylint: disable=unbalanced-tuple-unpacking if what not in ('lexer', 'formatter', 'filter'): print(usage, file=sys.stderr) return 2 return _print_help(what, name) # parse -O options parsed_opts = _parse_options(O_opts) opts.pop('-O', None) # parse -P options for p_opt in P_opts: try: name, value = p_opt.split('=', 1) except ValueError: parsed_opts[p_opt] = True else: parsed_opts[name] = value opts.pop('-P', None) # encodings inencoding = parsed_opts.get('inencoding', parsed_opts.get('encoding')) outencoding = parsed_opts.get('outencoding', parsed_opts.get('encoding')) # handle ``pygmentize -N`` infn = opts.pop('-N', None) if infn is not None: lexer = find_lexer_class_for_filename(infn) if lexer is None: lexer = TextLexer print(lexer.aliases[0]) return 0 # handle ``pygmentize -S`` S_opt = opts.pop('-S', None) a_opt = opts.pop('-a', None) if S_opt is not None: f_opt = opts.pop('-f', None) if not f_opt: print(usage, file=sys.stderr) return 2 if opts or args: print(usage, file=sys.stderr) return 2 try: parsed_opts['style'] = S_opt fmter = get_formatter_by_name(f_opt, **parsed_opts) except ClassNotFound as err: print(err, file=sys.stderr) return 1 print(fmter.get_style_defs(a_opt or '')) return 0 # if no -S is given, -a is not allowed if a_opt is not None: print(usage, file=sys.stderr) return 2 # parse -F options F_opts = _parse_filters(F_opts) opts.pop('-F', None) allow_custom_lexer_formatter = False # -x: allow custom (eXternal) lexers and formatters if opts.pop('-x', None) is not None: allow_custom_lexer_formatter = True # select lexer lexer = None # given by name? lexername = opts.pop('-l', None) if lexername: # custom lexer, located relative to user's cwd if allow_custom_lexer_formatter and '.py' in lexername: try: if ':' in lexername: filename, name = lexername.rsplit(':', 1) lexer = load_lexer_from_file(filename, name, **parsed_opts) else: lexer = load_lexer_from_file(lexername, **parsed_opts) except ClassNotFound as err: print('Error:', err, file=sys.stderr) return 1 else: try: lexer = get_lexer_by_name(lexername, **parsed_opts) except (OptionError, ClassNotFound) as err: print('Error:', err, file=sys.stderr) return 1 # read input code code = None if args: if len(args) > 1: print(usage, file=sys.stderr) return 2 if '-s' in opts: print('Error: -s option not usable when input file specified', file=sys.stderr) return 2 infn = args[0] try: with open(infn, 'rb') as infp: code = infp.read() except Exception as err: print('Error: cannot read infile:', err, file=sys.stderr) return 1 if not inencoding: code, inencoding = guess_decode(code) # do we have to guess the lexer? if not lexer: try: lexer = get_lexer_for_filename(infn, code, **parsed_opts) except ClassNotFound as err: if '-g' in opts: try: lexer = guess_lexer(code, **parsed_opts) except ClassNotFound: lexer = TextLexer(**parsed_opts) else: print('Error:', err, file=sys.stderr) return 1 except OptionError as err: print('Error:', err, file=sys.stderr) return 1 elif '-s' not in opts: # treat stdin as full file (-s support is later) # read code from terminal, always in binary mode since we want to # decode ourselves and be tolerant with it if sys.version_info > (3,): # Python 3: we have to use .buffer to get a binary stream code = sys.stdin.buffer.read() else: code = sys.stdin.read() if not inencoding: code, inencoding = guess_decode_from_terminal(code, sys.stdin) # else the lexer will do the decoding if not lexer: try: lexer = guess_lexer(code, **parsed_opts) except ClassNotFound: lexer = TextLexer(**parsed_opts) else: # -s option needs a lexer with -l if not lexer: print('Error: when using -s a lexer has to be selected with -l', file=sys.stderr) return 2 # process filters for fname, fopts in F_opts: try: lexer.add_filter(fname, **fopts) except ClassNotFound as err: print('Error:', err, file=sys.stderr) return 1 # select formatter outfn = opts.pop('-o', None) fmter = opts.pop('-f', None) if fmter: # custom formatter, located relative to user's cwd if allow_custom_lexer_formatter and '.py' in fmter: try: if ':' in fmter: file, fmtername = fmter.rsplit(':', 1) fmter = load_formatter_from_file(file, fmtername, **parsed_opts) else: fmter = load_formatter_from_file(fmter, **parsed_opts) except ClassNotFound as err: print('Error:', err, file=sys.stderr) return 1 else: try: fmter = get_formatter_by_name(fmter, **parsed_opts) except (OptionError, ClassNotFound) as err: print('Error:', err, file=sys.stderr) return 1 if outfn: if not fmter: try: fmter = get_formatter_for_filename(outfn, **parsed_opts) except (OptionError, ClassNotFound) as err: print('Error:', err, file=sys.stderr) return 1 try: outfile = open(outfn, 'wb') except Exception as err: print('Error: cannot open outfile:', err, file=sys.stderr) return 1 else: if not fmter: fmter = TerminalFormatter(**parsed_opts) if sys.version_info > (3,): # Python 3: we have to use .buffer to get a binary stream outfile = sys.stdout.buffer else: outfile = sys.stdout # determine output encoding if not explicitly selected if not outencoding: if outfn: # output file? use lexer encoding for now (can still be None) fmter.encoding = inencoding else: # else use terminal encoding fmter.encoding = terminal_encoding(sys.stdout) # provide coloring under Windows, if possible if not outfn and sys.platform in ('win32', 'cygwin') and \ fmter.name in ('Terminal', 'Terminal256'): # pragma: no cover # unfortunately colorama doesn't support binary streams on Py3 if sys.version_info > (3,): from pygments.util import UnclosingTextIOWrapper outfile = UnclosingTextIOWrapper(outfile, encoding=fmter.encoding) fmter.encoding = None try: import colorama.initialise except ImportError: pass else: outfile = colorama.initialise.wrap_stream( outfile, convert=None, strip=None, autoreset=False, wrap=True) # When using the LaTeX formatter and the option `escapeinside` is # specified, we need a special lexer which collects escaped text # before running the chosen language lexer. escapeinside = parsed_opts.get('escapeinside', '') if len(escapeinside) == 2 and isinstance(fmter, LatexFormatter): left = escapeinside[0] right = escapeinside[1] lexer = LatexEmbeddedLexer(left, right, lexer) # ... and do it! if '-s' not in opts: # process whole input as per normal... highlight(code, lexer, fmter, outfile) return 0 else: # line by line processing of stdin (eg: for 'tail -f')... try: while 1: if sys.version_info > (3,): # Python 3: we have to use .buffer to get a binary stream line = sys.stdin.buffer.readline() else: line = sys.stdin.readline() if not line: break if not inencoding: line = guess_decode_from_terminal(line, sys.stdin)[0] highlight(line, lexer, fmter, outfile) if hasattr(outfile, 'flush'): outfile.flush() return 0 except KeyboardInterrupt: # pragma: no cover return 0