def a8(dir):
file, dispfile, score_multiplier, output = get_start( dir, 1.0, "" )
if file == None:
return ( score_multiplier, output )
score_multiplier, output = comments_message( file, dispfile,
score_multiplier, output,
penalty = 0.10 )
max_score = 155
score = 0
mod = check_utils.ModuleWrapper( file )
sol = check_utils.ModuleWrapper( 'repositories/solutions/a8/start.py', name="solutions" )
mod.add_args_check( 'collapse',
pattern = ArgSpec( ['x'],None,None,None ) )
mod.add_func_test( 'collapse', 'Nested Structures',
check_utils.random_tuple_generator( lambda: rand_nest(),
50, 1 ),
check_utils.gen_evaluator( sol.collapse ) )
mod.add_args_check( 'edit_list',
pattern = ArgSpec( ['t','f'],None,None,None ) )
def el_tup(i,choices=None):
t = choices
if t == None:
t = range(10) * 3
if i == 0:
ret = random.sample(t,random.randrange(min(3,len(t)),min(20,len(t)+1)))
#print ret
return ret
elif choices != None:
return random.choice(t)
elif i == 1:
#print "func1"
return lambda x: [x] * ( x if type(x) == int else 2 )
else:
#print "func2"
return lambda x: [] if type(x) == int and x%2 == 0 else [x]
mod.add_func_test( 'edit_list', 'Expand',
check_utils.random_tuple_generator(lambda i: el_tup(i), 25, 2),
check_utils.gen_evaluator( sol.edit_list ) )
mod.add_func_test( 'edit_list', 'Remove Even',
check_utils.random_tuple_generator(lambda i: el_tup(i*2),
25, 2),
check_utils.gen_evaluator( sol.edit_list ) )
mod.add_args_check( 'remove_from_list',
pattern = ArgSpec( ['t','x'],None,None,None ) )
mod.add_func_test( 'remove_from_list', 'Integers',
check_utils.random_tuple_generator(
lambda i: el_tup(i,range(20)), 25, 2),
check_utils.gen_evaluator( sol.remove_from_list ) )
mod.add_func_test( 'remove_from_list', 'Characters',
check_utils.random_tuple_generator(
lambda i: el_tup(i,string.uppercase), 25, 2),
check_utils.gen_evaluator( sol.remove_from_list ) )
output,score = mod.run_func_checks( output, score )
return ((float(score)/float(max_score))*score_multiplier, output )
def a4( dir ):
file, dispfile, score_multiplier, output = get_start( dir, 1.0, "" )
score_multiplier, output = comments_message( file, dispfile,
score_multiplier, output,
penalty = 0.10 )
if file == None:
return ( score_multiplier, output )
max_score = 270
score = 0
mod = check_utils.ModuleWrapper( file )
mult_by_7_spec = ArgSpec( ['n','seven'], None, None, [ 7 ] )
ok, output, score = mod.check_args( 'mult_by_7', output, score,
multiplier = 10,
pattern = mult_by_7_spec )
if ok & ( mod.NOT_FOUND + mod.NOT_FUNC ) == 0:
output += 'testing'
def mb7( n, seven=7 ):
return n * seven
#check floats
output, score = check_utils.check_func(
mod.mult_by_7,
check_utils.random_tuple_generator( lambda: random.gauss(0,30),
count = 30, min_length = 1,
max_length = 2 ),
check_utils.gen_evaluator( mb7 ),
output, score )
#check ints
output, score = check_utils.check_func(
mod.mult_by_7,
check_utils.random_tuple_generator( lambda: int(random.gauss(0,100)),
count = 30, min_length = 1,
max_length = 2 ),
check_utils.gen_evaluator( mb7 ),
output, score )
output += "\n"
ok, output, score = mod.check_args( 'add_it_up', output, score,
multiplier = 10, min_args = 10 )
if ok & ( mod.NOT_FOUND + mod.NOT_FUNC ) == 0:
output += 'testing'
def addup( *args ):
return float(sum(args))
#check floating point values:
output, score = check_utils.check_func(
mod.add_it_up,
check_utils.random_tuple_generator( lambda: random.gauss(0,30),
count = 30, max_length = 10 ),
check_utils.gen_evaluator( addup ),
output, score )
#check integer values:
output, score = check_utils.check_func(
mod.add_it_up,
check_utils.random_tuple_generator( lambda: int(random.gauss(100,500)),
count = 30, max_length = 10 ),
check_utils.gen_evaluator( addup ),
output, score )
output += "\n"
alphabet_backwards_spec = ArgSpec( ['last_letter','length'], None, None,
['Z', 26] )
ok, output, score = mod.check_args( 'alphabet_backwards', output, score,
multiplier = 10,
pattern = alphabet_backwards_spec )
if ok & ( mod.NOT_FOUND + mod.NOT_FUNC ) == 0:
def gen_cases():
for i in range(60):
yield ( random.choice( string.uppercase + string.lowercase ),
random.randint(0,26) )
def aback( last_letter = 'Z', length = 26 ):
return "".join( map( lambda i: chr(ord(last_letter)-i), range(length) ) )
def aback_alt( last_letter = 'Z', length = 26 ):
a = 'A'
if last_letter.lower() == last_letter:
a = 'a'
return aback( last_letter,
min( length, ord(last_letter) - ord(a) + 1 ) )
best_out = ""
best_score = 0.0
for eval in [(aback,''),(aback_alt,'(alternate)')]:
outp, sc = check_utils.check_func(
mod.alphabet_backwards, gen_cases(),
check_utils.gen_evaluator( eval[0] ),
"testing"+eval[1], 0.0, multiplier = 2.0 )
if sc >= best_score:
best_out = outp
best_score = sc
output += best_out
score += best_score
output += "\n"
output += check_utils.check_func_key()
return ((float(score)/float(max_score))*score_multiplier, output )
def a7(dir):
file, dispfile, score_multiplier, output = get_start( dir, 1.0, "" )
if file == None:
return ( score_multiplier, output )
score_multiplier, output = comments_message( file, dispfile,
score_multiplier, output,
penalty = 0.10 )
max_score = 117
score = 0
print file
mod = check_utils.ModuleWrapper( file )
sol = check_utils.ModuleWrapper( 'repositories/solutions/a7/start.py', name = 'solution' )
def rand_thing(i=0,kind=None,noNest=False):
typegens = {
'short' : lambda: random.randrange(-32767,32767),
'bits' : lambda: random.getrandbits(64),
'int' : lambda: random.randint(0,2**32),
'string': lambda: "".join(random.sample(string.printable,
random.randrange(3,20))),
'list' : lambda: map( lambda x: rand_thing(noNest=True),
range(random.randrange(5,15)) ),
'dict' : lambda: dict( map( lambda x: (rand_thing(kind='string'),
rand_thing(noNest=True)),
range(random.randrange(3,7)) ) )
}
if kind == None:
if noNest:
klist = ['short','bits','int','string']
else:
klist = typegens.keys()
kind = random.choice(klist)
return typegens[kind]()
def rand_word():
return "".join(random.sample(string.letters,random.randrange(3,11)))
def rand_wordlist():
return map( lambda x: rand_word(), range(random.randrange(5,50)) )
def rand_wordlists(n):
return map( lambda x: rand_wordlist(), range(n) )
def build_and_lookup_fn(m):
print m
def fn( word_lists, lookup_list ):
word_lists = copy.deepcopy(word_lists)
lookup_list = copy.deepcopy(lookup_list)
wl1 = word_lists.pop()
try:
ll = m.build_letter_lookup( wl1 )
except:
ll = m.build_letter_lookup( wl1, {} )
while len(word_lists) > 0:
ll = m.build_letter_lookup( word_lists.pop(), ll )
#now do lookups:
return map( lambda w: set(m.lookup_letters( w, ll )),
lookup_list )
return fn
bnl_mod = build_and_lookup_fn(mod)
bnl_sol = build_and_lookup_fn(sol)
def mk_bnl_tupleval(n):
def bnl_tupleval(i):
if i == 0:
return rand_wordlists(n)
else:
return rand_wordlist()
return bnl_tupleval
mod.add_args_check( 'lookup_letters',
pattern = ArgSpec( ['word','letter_lookup'],
None, None, [] ) )
mod.add_args_check( 'build_letter_lookup',
pattern = ArgSpec( ['words','letter_lookup'],
None, None, [{}] ) )
mod.add_func_test( 'build_letter_lookup','Single wordlist',
check_utils.random_tuple_generator( mk_bnl_tupleval(1), 25, 2 ),
check_utils.gen_evaluator( bnl_sol ), function = bnl_mod )
mod.add_func_test( 'build_letter_lookup','Cumulative wordlists',
check_utils.random_tuple_generator( mk_bnl_tupleval(5), 25, 2 ),
check_utils.gen_evaluator( bnl_sol ), function = bnl_mod )
mod.add_args_check( 'multiply_anything',
pattern = ArgSpec( ['a','b'],None,None,[] ) )
mod.add_func_test( 'multiply_anything','Integers',
check_utils.random_tuple_generator( lambda: random.randint(-1000,1000),
25, 2 ),
check_utils.gen_evaluator( lambda x,y: x*y ) )
mod.add_args_check( 'explode', min_args = 1 )
err_types = set()
if hasattr(mod,'explode'):
explode_spec = inspect.getargspec( mod.getattr_raw('explode') )
print "explode_spec: ", explode_spec
min_args = len(explode_spec.args or []) - len(explode_spec.defaults or [])
max_args = len(explode_spec.args or [])
def test_explode(*args,**varargs):
try:
mod.explode(*args,**varargs)
except check_utils.WrappedError, w:
err_types.add(w.type.__name__)
return 1.0
except BaseException, e:
err_types.add(type(e).__name__)
return 1.0
else:
return 0.0
cases = map(lambda n: tuple([rand_drawitem(1,360)]),
range(15)),
evaluator = check_drawitem )
mod.add_func_test('to_xy', 'Crazy Angles', function = from_to_xy,
cases = map(lambda n: tuple([rand_drawitem(-720,720)]),
range(30)),
evaluator = check_drawitem )
mod.add_args_check( 'from_xy',
pattern = ArgSpec( ['coords'],None,None,[] ) )
mod.add_args_check( 'scale',
pattern = ArgSpec( ['factor','drawlist'],
None,None,[] ) )
mod.add_func_test( 'scale', 'Basic',
map(lambda n: (random.uniform(0.25,7), list(rand_drawlist())),
range(30)),
check_utils.gen_evaluator( sol.scale ) )
mod.add_args_check( 'polygon',
pattern = ArgSpec( ['n','len'], None, None, [] ) )
#mod.add_func_test( 'polygon', 'Basic',
# map(lambda n: (random.randrange(3,16), random.uniform(4,176)),
# range(30)),
# check_utils.gen_evaluator( sol.polygon ) )
mod.add_args_check( 'add_drawitems',
pattern = ArgSpec( ['a','b'], None, None, [] ) )
mod.add_args_check( 'simplify',
pattern = ArgSpec(
['min_distance','max_combinations','drawlist'],
None, None, [] ) )
mod.add_args_check( 'zigzag',
pattern = ArgSpec(
['item','angle_variance','length_variance'],
