Try Sneklang Online

sum([1, 2, 3])

SnekRuntimeError('NameError("\'sum\' is not defined")')

Link time elapsed: 0.333 ms

data = [(([1] * 1000) * 10) * 10 for _ in [1, 2, 3]*10000]

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 19.480 ms

data = [([1] * 1000) * 10 for _ in [1, 2, 3]*10000]

SnekRuntimeError("TimeoutError('This program has too many evaluations')")

Link time elapsed: 12337.318 ms

data = [([1] * 1000) * 10 for _ in [1, 2, 3]*1000]

SnekRuntimeError("TimeoutError('This program has too many evaluations')")

Link time elapsed: 12601.940 ms

data = [([1] * 1000) * 10 for _ in [1, 2, 3]]

[None]

Link time elapsed: 70.032 ms

data = [([1] * 10000) * 10 for _ in [1, 2, 3]]

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 3.441 ms

data = [([] * 10000) * 10 for _ in [1, 2, 3]]

[None]

Link time elapsed: 0.948 ms

data = [(b'1' * 10000) * 10 for _ in [1, 2, 3]]

SnekRuntimeError("MemoryError('Scope has used too much memory')")

Link time elapsed: 58.216 ms

data = [b'1' * 10000 for _ in [1, 2, 3]]

[None]

Link time elapsed: 98.158 ms

data = [b'1' * 10000 for _ in range(10)]

SnekRuntimeError('NameError("\'range\' is not defined")')

Link time elapsed: 0.481 ms

data = []
for _ in [1] * 1:
    data.append((b'1' + b'0' * 10000) * 10)

[None, None]

Link time elapsed: 3.110 ms

data = []
for _ in [1] * 2:
    data.append((b'1' + b'0' * 10000) * 10)

SnekRuntimeError("MemoryError('Scope has used too much memory')")

Link time elapsed: 5.328 ms

data = []
for _ in [1] * 10:
    data.append((b'1' + b'0' * 10000) * 10)

SnekRuntimeError("MemoryError('Scope has used too much memory')")

Link time elapsed: 4.988 ms

data = []
for _ in [1] * 100:
    data.append((b'1' + b'0' * 10000) * 10)

SnekRuntimeError("MemoryError('Scope has used too much memory')")

Link time elapsed: 63.824 ms

data = []
for _ in [1] * 10000:
    data.append((b'1' + b'0' * 10000) * 10)

SnekRuntimeError("MemoryError('Scope has used too much memory')")

Link time elapsed: 9.507 ms

data = []
for i in range(100):
    data.append((b'1' + b'0' * 10000) * 10)

SnekRuntimeError('NameError("\'range\' is not defined")')

Link time elapsed: 0.547 ms

(b'1' + b'0' * 10000) * 10

[b'1000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'000000000000000000000000…

Link time elapsed: 97.030 ms

(b'1' + b'0' * 10000) * 100

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 0.688 ms

(b'1' + b'0' * 10000) * 1000

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 0.664 ms

(b'1' + b'0' * 10000)

[b'1000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'000000000000000000000000…

Link time elapsed: 2.696 ms

(b'1' + b'0' * 10000) * 10000

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 0.628 ms

b'1000000000' * 10000

[b'1000000000100000000010000000001000000000100000000010000000001000000000100000'
 b'0000100000000010000000001000000000100000000010000000001000000000100000000010'
 b'0000000010000000001000000000100000000010000000001000000000100000000010000000'
 b'0010000000001000000000100000000010000000001000000000100000000010000000001000'
 b'0000001000000000100000000010000000001000000000100000000010000000001000000000'
 b'1000000000100000000010000000001000000000100000000010000000001000000000100000'
 b'0000100000000010000000001000000000100000000010000000001000000000100000000010'
 b'0000000010000000001000000000100000000010000000001000000000100000000010000000'
 b'0010000000001000000000100000000010000000001000000000100000000010000000001000'
 b'0000001000000000100000000010000000001000000000100000000010000000001000000000'
 b'1000000000100000000010000000001000000000100000000010000000001000000000100000'
 b'0000100000000010000000001000000000100000000010000000001000000000100000000010'
 b'000000001000000000100000…

Link time elapsed: 40.836 ms

b'1000' * 10000

[b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'1000100010001000100010001000100010001000100010001000100010001000100010001000'
 b'100010001000100010001000…

Link time elapsed: 102.012 ms

b'000' * 10000

[b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'000000000000000000000000…

Link time elapsed: 13.269 ms

b'00' * 10000

[b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'000000000000000000000000…

Link time elapsed: 46.999 ms

b'0' * 10000

[b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'0000000000000000000000000000000000000000000000000000000000000000000000000000'
 b'000000000000000000000000…

Link time elapsed: 2.311 ms

b'0' * 100000

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 0.409 ms

b'0' * 1000000

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 0.359 ms

b'0' * 10000000

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 0.331 ms

[b'100'][0] * 1000000

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 0.860 ms

b'100' * 10000000

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 0.480 ms

b'100' * 10000

[b'1001001001001001001001001001001001001001001001001001001001001001001001001001'
 b'0010010010010010010010010010010010010010010010010010010010010010010010010010'
 b'0100100100100100100100100100100100100100100100100100100100100100100100100100'
 b'1001001001001001001001001001001001001001001001001001001001001001001001001001'
 b'0010010010010010010010010010010010010010010010010010010010010010010010010010'
 b'0100100100100100100100100100100100100100100100100100100100100100100100100100'
 b'1001001001001001001001001001001001001001001001001001001001001001001001001001'
 b'0010010010010010010010010010010010010010010010010010010010010010010010010010'
 b'0100100100100100100100100100100100100100100100100100100100100100100100100100'
 b'1001001001001001001001001001001001001001001001001001001001001001001001001001'
 b'0010010010010010010010010010010010010010010010010010010010010010010010010010'
 b'0100100100100100100100100100100100100100100100100100100100100100100100100100'
 b'100100100100100100100100…

Link time elapsed: 66.524 ms

import random

SnekRuntimeError("ModuleNotFoundError('random')")

Link time elapsed: 0.335 ms

import sys

SnekRuntimeError("ModuleNotFoundError('sys')")

Link time elapsed: 0.770 ms

try:
	raise Exception("hello")
except Exception as exc:
	f = exc
print(f.__traceback__)

SnekRuntimeError("NotImplementedError('Sorry, access to this attribute is not available. (__traceback__)')")

Link time elapsed: 0.841 ms

try:
	raise Exception("hello")
except Exception as exc:
	f = exc
f

[None, SnekRuntimeError("Exception('hello')")]

Link time elapsed: 0.902 ms

try:
	raise Exception
except Exception as exc:
	f = exc
f

[None,
 SnekRuntimeError('TypeError("can\'t set attributes of built-in/extension type \'Exception\'")')]

Link time elapsed: 1.151 ms

try:
	raise ValueError
except Exception as exc:
	f = exc
f

[None, SnekRuntimeError('NameError("\'ValueError\' is not defined")')]

Link time elapsed: 0.943 ms

print(__builtins__)

SnekRuntimeError('NameError("\'__builtins__\' is not defined")')

Link time elapsed: 0.504 ms

import array

SnekRuntimeError("ModuleNotFoundError('array')")

Link time elapsed: 0.347 ms

print("hello")

[None]

Link time elapsed: 0.584 ms

[]

Link time elapsed: 0.795 ms

int.__bases__

SnekRuntimeError("NotImplementedError('Sorry, access to this attribute is not available. (__bases__)')")

Link time elapsed: 0.484 ms

"hello"

['hello']

Link time elapsed: 0.513 ms

import os 
print(os.name)

SnekRuntimeError("ModuleNotFoundError('os')")

Link time elapsed: 0.414 ms

import os

SnekRuntimeError("ModuleNotFoundError('os')")

Link time elapsed: 0.416 ms

a = ["hi", "world"]
" ".join(a)

[None, 'hi world']

Link time elapsed: 4.067 ms

x = 10
def foo():
    print(x)
    x += 1
    return x
foo()

[None, None, 11]

Link time elapsed: 1.801 ms

x = 10
def foo():
    print(x)
    x += 1
    
foo()

[None, None, None]

Link time elapsed: 2.046 ms

l = [0,1,2,3,4,65,7,8,9,19,43,25,6,743,2,3,3,651,1]
print({v: v**3 for v in l})

[None, None]

Link time elapsed: 3.879 ms

a = ["hi", "world"]
" ".join(a)
while True:
	pass

SnekRuntimeError("TimeoutError('This program has too many evaluations')")

Link time elapsed: 113.073 ms

l = [0,1,2,3,4,65,7,8,9,19,43,25,6,743,2,3,3,651,1]
{v: v**3 for v in l}

[None,
 {0: 0,
  1: 1,
  2: 8,
  3: 27,
  4: 64,
  6: 216,
  7: 343,
  8: 512,
  9: 729,
  19: 6859,
  25: 15625,
  43: 79507,
  65: 274625,
  651: 275894451,
  743: 410172407}]

Link time elapsed: 4.154 ms

l = [0,1,2,3,4,65,7,8,9]*10
{v: v**3 for v in l}
l

[None,
 {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 7: 343, 8: 512, 9: 729, 65: 274625},
 [0,
  1,
  2,
  3,
  4,
  65,
  7,
  8,
  9,
  0,
  1,
  2,
  3,
  4,
  65,
  7,
  8,
  9,
  0,
  1,
  2,
  3,
  4,
  65,
  7,
  8,
  9,
  0,
  1,
  2,
  3,
  4,
  65,
  7,
  8,
  9,
  0,
  1,
  2,
  3,
  4,
  65,
  7,
  8,
  9,
  0,
  1,
  2,
  3,
  4,
  65,
  7,
  8,
  9,
  0,
  1,
  2,
  3,
  4,
  65,
  7,
  8,
  9,
  0,
  1,
  2,
  3,
  4,
  65,
  7,
  8,
  9,
  0,
  1,
  2,
  3,
  4,
  65,
  7,
  8,
  9,
  0,
  1,
  2,
  3,
  4,
  65,
  7,
  8,
  9]]

Link time elapsed: 20.735 ms

l = [0,1,2,3,4,65,7,8,9]*10
{v: v**3 for v in l}
1

[None, {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 7: 343, 8: 512, 9: 729, 65: 274625}, 1]

Link time elapsed: 19.726 ms

l = [0,1,2,3,4,65,7,8,9]*10
{v: v**3 for v in l}

[None, {0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 7: 343, 8: 512, 9: 729, 65: 274625}]

Link time elapsed: 17.068 ms

a = ["hi", "world"] * 32


while True:
	a = [a,a] * 16

SnekRuntimeError("MemoryError('Sorry, I will not evalute something that long.')")

Link time elapsed: 36.079 ms

a, b = 0, 1
while a < 10:
    a, b = b, a+b
    
a

[None, None, 13]

Link time elapsed: 4.716 ms

(lambda f: f)(1)

[1]

Link time elapsed: 1.096 ms

(lambda f: 1)()

SnekRuntimeError('TypeError("<lambda>() missing a required argument: \'f\'")')

Link time elapsed: 1.958 ms

result = []
def my_decorator(log):
    result.append(f"d1 {log}")
    def _wrapper(func):
        result.append(f"_wrapper {log}")
        def _inner(*args, **kwargs):
            result.append(f"inner {log}")
            func(*args, **kwargs)
        return _inner
    return _wrapper
    
@my_decorator(1)
@my_decorator(2)
def say(word=None):
    result.append(word or "hi world!")
say()
say('ola mundo')
result

[None,
 None,
 None,
 None,
 None,
 ['d1 1',
  'd1 2',
  '_wrapper 2',
  '_wrapper 1',
  'inner 1',
  'inner 2',
  'hi world!',
  'inner 1',
  'inner 2',
  'ola mundo']]

Link time elapsed: 12.474 ms

a = 1
b = 2
exc_1, exc_2 = None, None

try:
	assert a == 1
except Exception as e:
	exc_1 = f"first exception {e}"
try:
	assert a == b
except Exception as e:
	exc_2 = f"False assertion: a == b"
	
exc_1
exc_2

[None, None, None, None, None, None, 'False assertion: a == b']

Link time elapsed: 1.466 ms

a = 1
b = 2
exc_1, exc_2 = None, None

try:
	assert a == 1
except Exception as e:
	exc_1 = f"first exception {e}"
try: assert a == b
except Exception as e: exc_2 = f"second exception {e}"
	
exc_1
exc_2

[None, None, None, None, None, None, 'second exception AssertionError()']

Link time elapsed: 1.642 ms

a = 1
b = 2
exc_1, exc_2 = None, None

try:
	assert a == 1
except Exception as e:
	exc_1 = f"first exception {e}"
try: assert a == b; except Exception as e: exc_2 = f"second exception {e}"
	
exc_1
exc_2

SnekRuntimeError('SyntaxError(\'invalid syntax\', (\'<unknown>\', 9, 21, \'try: assert a == b; except Exception as e: exc_2 = f"second exception {e}"\\n\'))')

Link time elapsed: 0.648 ms

a = 1
b = 2
exc_1, exc_2 = None, None

try:
	assert a == 1
except Exception as e:
	exc_1 = f"first exception {e}"
try: assert a == b; except Exception as e:mexc_2 = f"second exception {e}"
	
exc_1
exc_2

SnekRuntimeError('SyntaxError(\'invalid syntax\', (\'<unknown>\', 9, 21, \'try: assert a == b; except Exception as e:mexc_2 = f"second exception {e}"\\n\'))')

Link time elapsed: 0.208 ms

a = 1
b = 2
exc_1, exc_2 = None, None

try:
	assert a == 1
except Exception as e:
	exc_1 = f"first exception {e}"
try:
	assert a == b
except Exception as e:
	exc_2 = f"second exception {e}"
	
exc_1
exc_2

[None, None, None, None, None, None, 'second exception AssertionError()']

Link time elapsed: 88.900 ms

a = 1
b = 2
exc_1, exc_2 = None

try:
	assert a == 1
except Exception as e:
	exc_1 = f"first exception {e}"
try:
	assert a == b
except Exception as e:
	exc_2 = f"second exception {e}"
	
exc_1
exc_2

SnekRuntimeError("TypeError('cannot unpack non-iterable NoneType object')")

Link time elapsed: 1.297 ms

a = 1
b = 2
try:
	assert a == 1
except Exception as e:
	exc_1 = f"first exception {e}"
try:
	assert a == b
except Exception as e:
	exc_2 = f"second exception {e}"
	
exc_1
exc_2

SnekRuntimeError('NameError("\'exc_1\' is not defined")')

Link time elapsed: 1.164 ms

try:
	a = 1
	b = 2
	assert a == b
except Exception as e:
	exc = f"exception {e}"
	
exc
e

[None, 'exception AssertionError()', SnekRuntimeError('AssertionError()')]

Link time elapsed: 1.673 ms

try:
	a = 1
	b = 2
	assert a == 1
except Exception as e:
	exc = f"exception {e}"
	
exc
e

SnekRuntimeError('NameError("\'exc\' is not defined")')

Link time elapsed: 1.013 ms

a = ["hi", "world"]
" ".join(a)
import os
print(os.listdir())

SnekRuntimeError("ModuleNotFoundError('os')")

Link time elapsed: 0.800 ms

a = b,c= 1,2
a,b,c

[None, ((1, 2), 1, 2)]

Link time elapsed: 1.176 ms

a = b,c= 1,2

[None]

Link time elapsed: 7.585 ms

def x(a): a

x

[None, <function x at 0x3e940046ef70>]

Link time elapsed: 1.253 ms

assert False

SnekRuntimeError('AssertionError()')

Link time elapsed: 0.582 ms

raise Exception()

SnekRuntimeError('Exception()')

Link time elapsed: 0.432 ms

twice = lambda x: x * 2

twice(1)
twice(2)
twice(3)
twice("abc")

[None, 2, 4, 6, 'abcabc']

Link time elapsed: 3.222 ms

lambda f: 1

[<function <lambda> at 0x3e93fe29a1f0>]

Link time elapsed: 0.940 ms

try:
	a = 1
	b = 2
	assert a == 1
	assert a == b
except Exception as e:
	exc = f"exception {dir(e)}"
	
exc
e

SnekRuntimeError('NameError("\'dir\' is not defined")')

Link time elapsed: 1.222 ms

try:
	a = 1
	b = 2
	assert a == 1
	assert a == b
except Exception as e:
	exc = f"exception {e}"
	
exc
e

[None, 'exception AssertionError()', SnekRuntimeError('AssertionError()')]

Link time elapsed: 1.397 ms

try:
	a = 1
	b = 2
	assert a == b
	assert a == None
except Exception as e:
	exc = f"exception {e}"
	
exc
e

[None, 'exception AssertionError()', SnekRuntimeError('AssertionError()')]

Link time elapsed: 1.393 ms

try:
	a = 1
	b = 2
	assert a == b
	assert a == None
except Exception as e:
	exc = f"exception {e}"
	
exc

[None, 'exception AssertionError()']

Link time elapsed: 1.564 ms

try:
	assert False, "False"
except Exception as e:
	exc_1 = f"first exception {e}"
try:
	assert False
except Exception as e:
	exc_2 = f"second exception {e}"
	
exc_1
exc_2

[None,
 None,
 "first exception AssertionError('False')",
 'second exception AssertionError()']

Link time elapsed: 1.707 ms

assert 1 == 2, "nope"

SnekRuntimeError("AssertionError('nope')")

Link time elapsed: 0.524 ms

try:
	try:
		assert False, "False"
	except Exception as e:
		exc_1 = f"first exception {e}"
		raise Exception(exc_1) from e
except Exception as e:
	exc_2 = f"second exception {e}"
	
exc_1
exc_2

[None,
 "first exception AssertionError('False')",
 'second exception Exception("first exception AssertionError(\'False\')")']

Link time elapsed: 1.794 ms

try:
	assert False, "False"
except Exception as e:
	exc_1 = f"first exception {e}"
try:
	assert False, "False"
except Exception as e:
	exc_2 = f"second exception {e}"
	
exc_1
exc_2

[None,
 None,
 "first exception AssertionError('False')",
 "second exception AssertionError('False')"]

Link time elapsed: 1.796 ms

assert True, "True"
assert False, "False"
assert None

SnekRuntimeError("AssertionError('False')")

Link time elapsed: 4.147 ms

def ok():
	ok()
	
ok()

SnekRuntimeError("RecursionError('Sorry, stack is to large. The MAX_CALL_DEPTH is 32.')")

Link time elapsed: 6.623 ms

def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + d
            else:
                pre + [key, value]
    else:
        out = out + [indict]
    return out
    
dict_generator({"a": [1,2,3]})

SnekRuntimeError('TypeError(\'can only concatenate list (not "int") to list\')')

Link time elapsed: 5.338 ms

raise Exception("hey")

SnekRuntimeError("Exception('hey')")

Link time elapsed: 0.418 ms

try:
	assert False, "foo"
except Exception as e:
	exc = e
exc

[None, SnekAssertionError('foo')]

Link time elapsed: 0.790 ms

try:
	assert False, "foo"
except Exception as e:
	e

[None]

Link time elapsed: 1.025 ms

assert False, "foo"

SnekAssertionError('foo')

Link time elapsed: 0.416 ms

assert False

SnekAssertionError('')

Link time elapsed: 0.334 ms

assert 1 == 2

SnekAssertionError('')

Link time elapsed: 0.385 ms

def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for i, v in enumerate(value):
                    for d in dict_generator(v, pre + [key, i]):
                        out = out + [d]
            else:
    			out = out + [(pre, indict)]
    else:
        out = out + [(pre, indict)]
    return out
    
dict_generator({"a": [1,{"b": [4,5,{"c": "C"}]},3]})

TabError('inconsistent use of tabs and spaces in indentation', ('<unknown>', 14, 35, '    \t\t\tout = out + [(pre, indict)]\n'))

Link time elapsed: 135.825 ms

def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for i, v in enumerate(value):
                    for d in dict_generator(v, pre + [key, i]):
                        out = out + [d]
            else:
                out = out + [key, value]
    else:
        out = out + [(pre, indict)]
    return out
    
dict_generator({"a": [1,{"b": [4,5,{"c": "C"}]},3]})

[None,
 [(['a', 0], 1),
  (['a', 1, 'b', 0], 4),
  (['a', 1, 'b', 1], 5),
  'c',
  'C',
  (['a', 2], 3)]]

Link time elapsed: 17.758 ms

def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for i, v in enumerate(value):
                    for d in dict_generator(v, pre + [key, i]):
                        out = out + [d]
            else:
                out = pre + [key, value]
    else:
        out = out + [(pre, indict)]
    return out
    
dict_generator({"a": [1,{"b": [4,5,{"c": "C"}]},3]})

[None,
 [(['a', 0], 1),
  (['a', 1, 'b', 0], 4),
  (['a', 1, 'b', 1], 5),
  'a',
  1,
  'b',
  2,
  'c',
  'C',
  (['a', 2], 3)]]

Link time elapsed: 41.486 ms

assert false

NameNotDefined("'false' is not defined")

Link time elapsed: 15.317 ms

def ok:
	pass

SyntaxError('invalid syntax', ('<unknown>', 1, 7, 'def ok:\n'))

Link time elapsed: 0.143 ms

class ok:
	pass

FeatureNotAvailable('Sorry, ClassDef is not available in this evaluator')

Link time elapsed: 30.589 ms

Previous Evaluation