def main(): args = parser.parse_args() if sum((args.list_of_stdin, args.lines_of_stdin)) > 1: err('Pythonpy accepts at most one of [-x, -l] flags') sys.exit(1) if args.pre_cmd: import_expression.exec(args.pre_cmd) if not args.expression and args.post_cmd: import_expression.exec(args.post_cmd) sys.exit(0) stdin = map(str.rstrip, sys.stdin) # ignore trailing newline if args.input_delimiter: split = re.compile(args.input_delimiter).split stdin = (split(l.rstrip()) for l in stdin) if args.output_delimiter: def fprint(x, join=args.output_delimiter.join): if x is not None: print(join(x)) else: def fprint(x): if x is not None: print(x) code = import_expression.compile(args.expression, '<pythonpy expression>', 'eval') if args.list_of_stdin: l = list(stdin) it = [import_expression.eval(code, dict(l=l))] elif args.lines_of_stdin: it = (import_expression.eval(code, dict(x=line)) for line in stdin) else: it = [import_expression.eval(code)] for x in it: try: it = [x] if isinstance(x, str) else iter(x) except TypeError: # not iterable fprint(x) else: for x in it: fprint(x) if args.post_cmd: import_expression.exec(args.post_cmd)
def main(): args = parser.parse_args() if sum((args.list_of_stdin, args.lines_of_stdin)) > 1: err('Pythonpy accepts at most one of [-x, -l] flags') sys.exit(1) if args.pre_cmd: import_expression.exec(args.pre_cmd) if not args.expression and args.post_cmd: import_expression.exec(args.post_cmd) sys.exit(0) stdin = without_trailing(map(str.rstrip, sys.stdin), trailing='') # ignore trailing newline code = import_expression.compile(args.expression, '<pythonpy expression>', 'eval') if args.list_of_stdin: l = list(stdin) it = [import_expression.eval(code, dict(l=l))] elif args.lines_of_stdin: it = (import_expression.eval(code, dict(x=line)) for line in stdin) else: it = [import_expression.eval(code)] for x in it: if x is None: continue try: it = [x] if isinstance(x, str) else iter(x) except TypeError: # not iterable print(x) else: for x in it: print(x) if args.post_cmd: import_expression.exec(args.post_cmd)
def test_eval_exec(): import ipaddress import textwrap import urllib.parse assert ie.eval('collections!.Counter(urllib.parse!.quote("foo"))') == dict(f=1, o=2) assert ie.eval('ipaddress!.IPV6LENGTH') == ipaddress.IPV6LENGTH assert ie.eval('urllib.parse!.quote("?")') == urllib.parse.quote('?') g = {} ie.exec(textwrap.dedent(""" a = urllib.parse!.unquote def b(): return operator!.concat(a('%3F'), a('these_tests_are_overkill_for_a_debug_cog%3D1'))""" ), g) assert g['b']() == '?these_tests_are_overkill_for_a_debug_cog=1' g = {} ie.exec(textwrap.dedent(""" def foo(x): x = x + 1 x = x + 1 x = x + 1 x = x + 1 def bar(): return urllib.parse!.unquote('can%20we%20make%20it%20into%20jishaku%3F') # the hanging indent on the following line is intentional return bar()""" ), g) assert g['foo'](1) == 'can we make it into jishaku?'
async def src(self, ctx, *, command): cmd = self.bot.get_command(command) if not cmd: try: obj = import_expression.eval(command, {}) except Exception as exc: await ctx.message.add_reaction(self.bot.tick_no) return await ctx.send_as_paginator(format_exc(exc), codeblock=True, destination=ctx.author) else: obj = cmd.callback lines, firstlno = inspect.getsourcelines(obj) paginator = BetterPaginator('```py\n', '```') for lno, line in enumerate(lines, start=firstlno): paginator.add_line(f'{lno}\t{line.rstrip()}'.replace('``', '`\u200b`')) await PaginationHandler(self.bot, paginator, no_help=True).start(ctx)
def main( color: str, variable: str, function: str, level_name: str, start: float, stop: float, step: float, y_limit: float, epsilon: float, scale: float, rounding: int, inclusive: bool, ) -> None: time_start = time.perf_counter() print("Processing...") try: color_value = int(color.replace("#", "0x"), 16) except ValueError: return click.echo(f"Can not parse color: {color!r}.") print("Parsing and compiling function...") try: environment: Dict[str, Any] = {} exec(SETUP, environment) function_to_call = import_expression.eval( f"lambda {variable}: {function}", environment) except SyntaxError: return click.echo(f"Can not parse function: {function!r}.") y_limit *= GRID_UNITS print("Preparing database and levels...") database, levels = prepare_database_and_levels() print("Preparing the level and the editor...") level, editor = prepare_level_and_editor(level_name) color_id = editor.get_free_color_id() if color_id is None: print("Can not find free color ID to use.") exit(1) print(f"Free color ID: {color_id}.") origin = gd.api.Object( id=POINT_OBJECT_ID, x=0, y=0, color_1_id=color_id, color_2_id=color_id, scale=ORIGIN_SCALE, ) editor.add_objects(origin) add_colors_and_background(editor, color_id, color_value) point_iterator = generate_coordinates( number_range(start, stop, step, inclusive=inclusive, rounding=rounding), wrap_failsafe(function_to_call), scale, ) print("Generating points...") points = [(x, y) for (x, y) in point_iterator if abs(y) < y_limit] print("Generating points to be skipped...") skip = { n * scale for n in number_range( start, stop, step, inclusive=inclusive, rounding=rounding) }.difference(x for x, y in points) print("Applying Ramer-Douglas-Peucker (RDP) algorithm...") actual_points = douglas_peucker(points, epsilon) print("Generating objects...") editor.objects.extend(generate_objects(actual_points, color_id, skip)) print("Shifting objects to the right...") lowest_x = abs(min(map(get_x, editor.get_objects()), default=0.0)) for gd_object in editor.get_objects(): gd_object.move(x=lowest_x) print("Saving...") dump_entities(database, levels, level, editor) time_stop = time.perf_counter() time_spent = time_stop - time_start if time_spent > 1: time_spent = round(time_spent, 2) time_string = f"{time_spent}s" else: time_spent = round(time_spent * 1000, 2) time_string = f"{time_spent}ms" print(f"Done. Objects used: {len(editor.get_objects())}. " f"Time spent: {time_string}.")
def test_kwargs(): # See https://github.com/bmintz/import-expression-parser/issues/1 ie.compile('f(**a)', mode='eval') import collections assert ie.eval('dict(x=collections!)')['x'] is collections