def pick_ingredient():
# This is horrifyingly inefficient
item = choice(list(components['ingredients'].items()))
item[1]['name'] = item[0]
item = item[1]
part = (choice(list(components['parts'][item['type']].items()))
if item['parts'] else None)
# Item types: animal, plant, fungus, solid, liquid, intangible
# Part types: solid, liquid, intangible
type = part[1] if part else item['type']
attributes = components['attributes']['general']
if type != 'intangible':
count, pluralize = choice(list(zip(counts, plurals)))
else:
count, pluralize = None, False
if type in ('solid', 'liquid'):
# Note no +=! For lists, += modifies the original list!
attributes = attributes + components['attributes'][type]
attribute = choice(attributes) if maybe(0.25) else None
measure = choice(components['measures'][type])
ingredient = f'{part[0]} of {item["name"]}' if part else item['name']
item = {'item': ingredient, 'type': type}
ingredient = ' '.join((
str(count),
plural(measure) if pluralize else measure,
f'{attribute} {ingredient}' if attribute else ingredient,
))
if maybe(0.2):
ingredient += f', {choice(components["preparations"][type])}'
else:
ingredient = item['name']
if part:
ingredient = f'{part[0]} of {ingredient}'
elif type == 'animal' and flip():
ingredient = f'live {ingredient}'
if pluralize:
ingredient = plural(ingredient)
item = {'item': ingredient, 'type': type}
if maybe(0.25):
ingredient = f'{choice(attributes)} {ingredient}'
if count:
ingredient = f'{count} {ingredient}'
return item, ingredient
def test_iteration():
for v in maybe(1):
assert v == 1
break
else:
pytest.fail('Expected value to be unpacked')
for _ in maybe(None):
pytest.fail('Expected no value to be unpacked')
assert True
def test_delegators():
class Bunch:
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
obj = maybe(Bunch(x=Bunch(y=Bunch(z=1))))
assert obj._.x._.y._.z.val == 1
obj = maybe(Bunch(x=Bunch(y=None)))
assert obj._.x._.y._.z.is_nothing
def syllable(first=True, last=True):
"""
Usually start with a consonant (or consonant combination), add vowel,
optionally add another vowel, and optionally end with a consonant.
"""
initial = (choice(INITIAL if first else INITIAL +
TERMINAL) if not first or maybe(0.75) else '')
vowel = choice(VOWELS)
extension = (choice_without(VOWELS, vowel if vowel not in 'eo' else None)
if maybe(0.25) else '')
terminal = choice(TERMINAL) if last and maybe(0.75) else ''
return initial + vowel + extension + terminal
def generate_cover(title, authors):
cover = f'## {title}\n\n### {authors[0]}'
if maybe(0.2):
cover += f'\n\n{choice(books["editions"]).capitalize()} Edition'
for role in books['roles']:
if maybe(0.2):
cover += f'\n\n{role.capitalize()} by {name()}'
contributors = oxford(authors[2:])
cover += f'\n\nWith thanks to {contributors} for their contributions.'
return cover
def test_monad_low():
def f(x):
return maybe(x + 1)
def g(x):
return maybe(x + 2)
# 1. bind(unit(x), f) === f(x)
assert maybe(1).flatmap(f) == f(1)
# 2. bind(m, unit) === m
assert maybe(1).flatmap(maybe) == maybe(1)
# 3. bind(bind(m, f), g) === bind(m, x => bind(f(x), g))
assert maybe(1).flatmap(f).flatmap(g) == maybe(1).flatmap(lambda x: f(x).flatmap(g))
def load_tests(refs, **kwargs):
ref_test = {}
basedir = maybe(kwargs, 'basedir', None)
verbose = maybe(kwargs, 'verbose', False)
#if not hasattr(refs,'next'):
# refs = [refs]
try:
for ref in refs:
ref_test = load_test(ref,**kwargs)
if not hasattr(ref_test,'items'):
print ref_test
ref_test = dict(ref_test)
except SyntaxError as e:
stderr.write("Could not parse reference file {}\n".format(ref.name))
exit(1)
return ref_test
def test_lazyness():
add_called = False
def add1(val):
nonlocal add_called
add_called = True
return val + 1
assert maybe.lazy(v
for x in maybe(None)
for v in add1(x)).is_nothing
assert not add_called
def load_test(ref,**kwargs):
(basedir,name) = path.split(ref.name)
if 'basedir' in kwargs:
basedir = kwargs['basedir']
name = ref.name
verbose = maybe(kwargs,'verbose', False)
ref_test = literal_eval(ref.read())
ref_test['basedir'] = basedir
if 'problems' in ref_test:
if verbose:
stderr.write("Reading problemset file {}\n".format(ref.name))
ref_test = load_problem_set(ref_test,basedir)
return (name,ref_test)
def questionFun(emailContact):
emailContact = emailContact
print("""
_ _ _ _ _ _ _
| || |_____ __ __ | |_ ___ __ _ __| |__ __ _ __ _(_)_ _| | ___ _ _| |_
| __ / _ \ V V / | _/ _ \ / _` (_-< / / / _` | / _` | | '_| | / _ \ || | _|
|_||_\___/\_/\_/ \__\___/ \__,_/__/_\_\ \__,_| \__, |_|_| |_| \___/\_,_|\__|
|___/
""")
answer = input("Will you go on a date? \n(yes, no, maybe): ")
answer = answer.lower()
if answer == "yes" or answer == "y":
yes.yes(emailContact)
elif answer == "no" or answer == "n":
no.no(emailContact)
elif answer == "maybe" or answer == "m":
maybe.maybe(emailContact)
else:
confirmEmail.ians(emailContact)
os.system("clear")
print('Not a valid answer, please try again')
questionFun(emailContact)
def test_getitem():
d = { 'x': { 'y': { 'z': 1 }, 'p': None } }
assert maybe(d)._['x']._['y']._['z'].val == 1
assert maybe(d)._['x']._['p']._['q'].is_nothing
assert maybe(d)._['x']._['y']._['a'].is_nothing
l = [[1], [2], None]
assert maybe(l)._[0]._[0].val == 1
assert maybe(l)._[0]._[1].is_nothing
assert maybe(l)._[2]._[1].is_nothing
def parse_actions(actions, **kwargs):
stderr.write("kwargs keys: {}\n".format(kwargs.keys()))
to_review = []
action_callers = {'review': lambda x,**k: to_review.append(x), 'suggest': on_suggest, 'test': on_test}
verbose = maybe(kwargs,'verbose',False)
if verbose:
stderr.writelines("action -- {}\n".format(action) for action in actions)
for (action, args) in imap(lambda x: x.split(':'), actions):
try:
action_callers[action](args.strip(), **kwargs)
except KeyError as e:
stderr.write("Action '{}' is not implemented\n".format(action))
stderr.write("Reviewing: {}\n".format(to_review))
kwargs['nowait']=True
for review in to_review[:-1]:
on_review(review, **kwargs)
kwargs['nowait']=False
on_review(to_review[-1], **kwargs)
def grouped_directions(liquid, solid, other):
directions = choice([
f'Combine {oxford(liquid)}.',
f'Add {oxford(liquid)}, stirring gently.',
f'Beat together {oxford(liquid)} until frothy.',
f'Pour {oxford(liquid)} into prepared vessel.',
])
if maybe(0.33):
directions += ' Bring to a boil, stirring ' + choice([
'vigorously.', 'continuously.', 'occasionally.', 'intermittently.',
'once.'
])
elif flip():
directions += (
' Lower the temperature until the mixture begins to congeal.')
next_direction = choice([
f'Stir in {oxford(solid)}, individually.',
f'Blend in {oxford(solid)}, stirring until fully dissolved.',
f'Add {oxford(solid)}.' + (' Do not overmix.' if flip() else ''),
f'Beat in {oxford(solid)} until only a few chunks remain.',
])
directions += '\n\n' + optional_action(next_direction)
if other:
next_direction = ' '.join([
choice([
f'Add {i}.',
f'Carefully add {i}.',
f'Cautiously add {i}.',
f'Blend in {i}.',
f'Fold in {i}.',
f'Combine with {i}.',
f'Add {i} and mix thoroughly.',
]) for i in other
])
directions += '\n\n' + optional_action(next_direction)
return directions
def generate_page(authors):
# Generate spell title
spell = choice(list(spells['spells'].keys()))
title = choice(spells['spells'][spell])
afflicted = choice(parts) if spell in ('blight', 'cure') else None
target = plural(choice(summons))
if flip():
title = f'{choice(spells["attributes"])} {title}'
if spell == 'cure':
title += ' for '
else:
title += ' of '
if spell == 'summoning':
title += target
elif spell in ('blight', 'cure'):
title += f'{choice(spells["maladies"])} {afflicted}'
else:
title += choice(spells['subjects'])
if maybe(0.2):
title = f"{choice(authors).split()[0]}'s {title}"
title = titlecase(title)
# Generate list of ingredients
items, ingredients = generate_ingredients()
ingredients = f'\n* ' + '\n* '.join(ingredients)
# Generate directions
directions = generate_directions(items, spell, afflicted, authors, target)
page = '\n\n'.join((
f'## {title}',
f'### Ingredients\n{ingredients}',
f'### Directions\n\n{directions}',
))
return page
def collect_problem(path, problem, **kwargs):
verbose = False
if 'verbose' in kwargs:
verbose = kwargs['verbose']
points=0
comments = []
total_points = maybe(problem, 'points', int(0))
try:
with open(os.path.join(path,problem['src']), 'r') as f:
(points,comments) = collect_points(f)
except IOError as e:
points = -total_points
comments.append((problem['src'],0,'Could not find source file\n'))
subtotal = total_points+points
if verbose:
sys.stderr.write("\tpoints for {}: {}/{}\n".format(problem['src'],subtotal,total_points))
sys.stderr.writelines("\t{}:{} {}".format(fname,lineno,line) for (fname,lineno,line) in comments if not line.strip() == '###DKM')
return (subtotal, total_points, comments)
def individual_directions(items):
directions = choice([
f'Start with {items[0]["item"]}.',
f'To begin, add {items[0]["item"]}.',
f'First, add {items[0]["item"]}.',
f'Add {items[0]["item"]} to the prepared vessel.',
])
for i in items[1:]:
if i['type'] == 'liquid':
next_direction = choice([
f'Add {i["item"]}.',
f'Pour in {i["item"]}.',
f'Mix in {i["item"]}.',
]) + (f' Stir {choice(["vigorously", "gently", "once"])}.'
if flip() else '')
elif i['type'] == 'solid':
next_direction = choice([
f'Add {i["item"]}.',
f'Mix in {i["item"]}.',
f'Fold in {i["item"]}.',
])
else:
next_direction = choice([
f'Add {i["item"]}.',
f'Carefully add {i["item"]}.',
f'Cautiously add {i["item"]}.',
f'Blend in {i["item"]}.',
f'Fold in {i["item"]}.',
f'Combine with {i["item"]}.',
f'Add {i["item"]} and mix thoroughly.',
])
directions += '\n\n' if maybe(0.2) else ' '
directions += optional_action(next_direction, 0.2)
return directions
def g(x):
return maybe(x + 2)
def test_nothing_maps_to_nothing():
assert maybe(None).map(lambda x: x + 1) == nothing
def f(x):
return maybe(x + 1)
def wrapper(value: Maybe[T]) -> Maybe[U]:
try:
return maybe(f(value))
except Exception:
return Nothing()
def test_map_applies_func_to_just_val():
assert maybe(1).map(lambda x: x + 1) == maybe(2)
def optional_action(direction, chance=0.5):
return action() + uncapitalize(direction) if maybe(chance) else direction
def test_unpacking():
val, exists = maybe(1).unpack()
assert (val, exists) == (1, True)
val, exists = maybe(None).unpack()
assert (val, exists) == (None, False)
def test_flatmap_accepts_funcs_returning_maybe():
assert maybe(1).flatmap(lambda x: maybe(x + 1)) == maybe(2)
for commented_file in commented_files:
if not os.path.basename(commented_file) in [ problem['src'] for problem in homework['problems']]:
homework['problems'].append({'src': os.path.basename(commented_file)})
results = [ collect_problem(path,problem,verbose=args.verbose) for problem in homework['problems'] ]
comments_file = scholar.comments_file(pid)
if args.verbose:
sys.stderr.write("Writing comments to {}\n".format(comments_file))
student_total = 0
f = StringIO.StringIO()
for (problem, (subtotal, outof, comments)) in zip(homework['problems'], results):
if outof > 0:
point_report="{}/{}".format(subtotal,outof)
else:
point_report="{}".format(subtotal)
f.write("## {}: {}\n\n".format(problem['src'], point_report))
if args.verbose:
sys.stderr.write("{} comments: {}\n".format(problem['src'], comments))
f.writelines("\tline {}: {}\n".format(lineno, comment.strip()) for (fname,lineno,comment) in comments if not comment.strip() == '###DKM' )
f.write("\n")
student_total += subtotal
f.write("\n*subtotal:* {}/{}\n".format(student_total, sum(maybe(x, 'points', 0) for x in homework['problems'])))
if args.verbose:
sys.stderr.write("Markdown comments:\n{}".format(f.getvalue()))
scholar.write_comments(pid,f.getvalue())
f.close()
print "{} {}".format(pid,student_total)
def test_bool():
assert maybe(1)
assert not maybe(None)
def test_get():
assert maybe(1).get() == 1
assert maybe(None).get(-1) == -1
def __init__(self, subtries=None):
if subtries is None:
subtries = {}
self.subtries = maybe(subtries)
