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