def new_quiz(request):
"""
Creates a new quiz but doesn't create any 'card' models.
Card models will only be used for cardbox in future.
"""
body = json.loads(request.body)
params = validate_params(body['min'], body['max'], body['length'],
body['lex'])
if isinstance(params, basestring):
return response(params, status=400)
p_min, p_max, length, lexicon = params
min_pk = alphProbToProbPK(p_min, lexicon.pk, length)
max_pk = alphProbToProbPK(p_max, lexicon.pk, length)
alpha_pks = range(min_pk, max_pk + 1)
li, q_map = savedlist_from_alpha_pks(alpha_pks, lexicon)
if len(q_map) > 0:
# Generate a quiz name.
quiz_name = '%s %ss (%s to %s)' % (lexicon.lexiconName, length, p_min,
p_max)
else:
quiz_name = ''
return response({
'list': li.to_python(),
'q_map': q_map,
'quiz_name': quiz_name
})
def load_into_cardbox(request):
body = json.loads(request.raw_post_data)
lexicon = Lexicon.objects.get(lexiconName=body['lex'].upper())
min_pk = alphProbToProbPK(int(body['min']), lexicon.pk,
int(body['length']))
max_pk = alphProbToProbPK(int(body['max']), lexicon.pk,
int(body['length']))
rg = range(min_pk, max_pk + 1)
# For every alphagram, see if we already have a card for this user,
# if not, create it.
user_cards = Card.objects.filter(user=request.user)
start = time.time()
now = datetime.today()
for ppk in rg:
# Create a new card.
try:
card = Card(alphagram=Alphagram.objects.get(probability_pk=ppk),
user=request.user, next_scheduled=now)
except Alphagram.DoesNotExist:
continue
try:
card.save()
except IntegrityError:
# Already exists, don't save again.
pass
logger.debug('Created Cards in %s s' % (time.time() - start))
return response({'num_cards': Card.objects.filter(
user=request.user).count()
})
def new_quiz(request):
"""
Creates a new quiz but doesn't create any 'card' models.
Card models will only be used for cardbox in future.
"""
body = json.loads(request.raw_post_data)
params = validate_params(body['min'], body['max'], body['length'],
body['lex'])
if isinstance(params, basestring):
return response(params, status=400)
p_min, p_max, length, lexicon = params
min_pk = alphProbToProbPK(p_min, lexicon.pk, length)
max_pk = alphProbToProbPK(p_max, lexicon.pk, length)
alpha_pks = range(min_pk, max_pk + 1)
li, q_map = savedlist_from_alpha_pks(alpha_pks, lexicon)
if len(q_map) > 0:
# Generate a quiz name.
quiz_name = '%s %ss (%s to %s)' % (lexicon.lexiconName, length,
p_min, p_max)
else:
quiz_name = ''
return response({'list': li.to_python(),
'q_map': q_map,
'quiz_name': quiz_name})
def searchForAlphagrams(data):
""" searches for alphagrams using form data """
lex = Lexicon.objects.get(lexiconName=data['lexicon'])
length = int(data['wordLength'])
minP = alphProbToProbPK(data['probabilityMin'], lex.pk, length)
maxP = alphProbToProbPK(data['probabilityMax'], lex.pk, length)
return SearchDescription.probPkIndexRange(minP, maxP, lex)
def handle(self, *args, **options):
if len(args) != 5:
raise CommandError("Args: lexicon_name min_prob max_prob length "
"mode where mode is missed or unasked")
lexicon = Lexicon.objects.get(lexiconName=args[0])
length = int(args[3])
min_prob = int(args[1])
max_prob = int(args[2])
min_pk = alphProbToProbPK(min_prob, lexicon.pk, length)
max_pk = alphProbToProbPK(max_prob, lexicon.pk, length)
# Get all alphagrams between these probabilities.
alphagrams = Alphagram.objects.filter(probability_pk__gte=min_pk,
probability_pk__lte=max_pk)
def handle(self, *args, **options):
lex = Lexicon.objects.get(lexiconName='OWL2')
lengthCounts = json.loads(lex.lengthCounts)
for length in range(5, 10):
for prob in range(1, lengthCounts[str(length)], 1000):
ppk_low = alphProbToProbPK(prob, lex.pk, length)
ppk_high = alphProbToProbPK(prob+999, lex.pk, length)
alphas = Alphagram.objects.filter(probability_pk__range=(ppk_low, ppk_high) )
f = open('../wordsdir/%ds__%05d_to_%05d.txt' % (length, prob, len(alphas) + prob - 1), 'wb')
for alpha in alphas:
words = alpha.word_set.all()
f.write(alpha.alphagram)
for word in words:
f.write(' ' + word.word)
f.write('\n')
f.close()
def generateDailyChallengePks(self, challengeName, lex, chDate):
# capture number. first try to match to today's lists
m = re.match("Today's (?P<length>[0-9]+)s",
challengeName.name)
if m:
wordLength = int(m.group('length'))
if wordLength < 2 or wordLength > 15:
return None # someone is trying to break my server >:(
logger.info('Generating daily challenges %s %d', lex, wordLength)
minP = 1
# lengthCounts is a dictionary of strings as keys
maxP = json.loads(lex.lengthCounts)[repr(wordLength)]
r = range(minP, maxP + 1)
random.shuffle(r)
r = r[:50] # just the first 50 elements for the daily challenge
pks = [alphProbToProbPK(i, lex.pk, wordLength) for i in r]
return pks, challengeName.timeSecs
else:
if challengeName.name == DailyChallengeName.WEEKS_BINGO_TOUGHIES:
from wordwalls.management.commands.genMissedBingoChalls import(
genPks)
mbs = genPks(lex, chDate)
pks = [mb[0] for mb in mbs]
random.shuffle(pks)
return pks, challengeName.timeSecs
elif challengeName.name == DailyChallengeName.BLANK_BINGOS:
questions = self.generate_blank_bingos_challenge(lex, chDate)
random.shuffle(questions)
return questions, challengeName.timeSecs
elif challengeName.name == DailyChallengeName.BINGO_MARATHON:
pks = []
for lgt in (7, 8):
min_p = 1
max_p = json.loads(lex.lengthCounts)[str(lgt)]
r = range(min_p, max_p + 1)
random.shuffle(r)
pks += [alphProbToProbPK(i, lex.pk, lgt) for i in r[:50]]
return pks, challengeName.timeSecs
elif challengeName.name in (DailyChallengeName.COMMON_SHORT,
DailyChallengeName.COMMON_LONG):
questions = self.generate_common_words_challenge(
challengeName.name)
random.shuffle(questions)
return questions, challengeName.timeSecs
return None
def createDatabases():
# on my macbook pro this script takes like 30 minutes to run total for the three lexica.
for d in dbsToCreate:
dbName, dbDescription = d
conn = sqlite3.connect(dbName+'.db')
c = conn.cursor()
lex = Lexicon(lexiconName = dbName, lexiconDescription = dbDescription)
lex.save() # write lexicon to database
c.execute("select alphagram, words, probability, length from alphagrams")
lengthsDict = {}
rc = 0
times = [0, 0, 0, 0, 0, 0]
for row in c:
t = time.time()
prob = row[2] & ((1 << 24) - 1)
lexIndex = lex.pk
length = row[3]
times[0] += time.time() - t
t = time.time()
a = Alphagram(alphagram=row[0], probability=prob, length=length,
probability_pk=alphProbToProbPK(prob, lexIndex, length), lexicon=lex)
times[5] += time.time() - t
t = time.time()
a.save() # write alphagram to database
times[1] += time.time() - t
if row[3] in lengthsDict:
lengthsDict[row[3]] += 1
else:
lengthsDict[row[3]] = 1
t = time.time()
wc = conn.cursor()
for str in row[1].split():
x = time.time()
wc.execute("select definition, lexiconstrings, front_hooks, back_hooks "
"from words where word = ?", (str,))
times[2] += time.time() - x
for wordrow in wc:
x = time.time()
w = Word(word=str,
lexiconSymbols=wordrow[1] if wordrow[1] else '',
front_hooks=wordrow[2] if wordrow[2] else '',
back_hooks=wordrow[3] if wordrow[3] else '',
definition=wordrow[0] if wordrow[0] else '')
w.alphagram = a
w.lexicon = lex
w.save()
times[3] += time.time() - x
times[4] += time.time() - t
rc += 1
if rc % 2000 == 0:
print rc, times
times = [0, 0, 0, 0, 0, 0]
lex.lengthCounts = json.dumps(lengthsDict)
lex.save()
print lex.lengthCounts
print "Done with", dbName
def generateDailyChallengePks(self, challengeName, lex, chDate):
# capture number. first try to match to today's lists
m = re.match("Today's (?P<length>[0-9]+)s", challengeName.name)
if m:
wordLength = int(m.group('length'))
if wordLength < 2 or wordLength > 15:
return None # someone is trying to break my server >:(
logger.info('Generating daily challenges %s %d', lex, wordLength)
minP = 1
# lengthCounts is a dictionary of strings as keys
maxP = json.loads(lex.lengthCounts)[repr(wordLength)]
r = range(minP, maxP + 1)
random.shuffle(r)
r = r[:50] # just the first 50 elements for the daily challenge
pks = [alphProbToProbPK(i, lex.pk, wordLength) for i in r]
return pks, challengeName.timeSecs
else:
if challengeName.name == DailyChallengeName.WEEKS_BINGO_TOUGHIES:
from wordwalls.management.commands.genMissedBingoChalls import (
genPks)
mbs = genPks(lex, chDate)
pks = [mb[0] for mb in mbs]
random.shuffle(pks)
return pks, challengeName.timeSecs
elif challengeName.name == DailyChallengeName.BLANK_BINGOS:
questions = self.generate_blank_bingos_challenge(lex, chDate)
random.shuffle(questions)
return questions, challengeName.timeSecs
elif challengeName.name == DailyChallengeName.BINGO_MARATHON:
pks = []
for lgt in (7, 8):
min_p = 1
max_p = json.loads(lex.lengthCounts)[str(lgt)]
r = range(min_p, max_p + 1)
random.shuffle(r)
pks += [alphProbToProbPK(i, lex.pk, lgt) for i in r[:50]]
return pks, challengeName.timeSecs
elif challengeName.name in (DailyChallengeName.COMMON_SHORT,
DailyChallengeName.COMMON_LONG):
questions = self.generate_common_words_challenge(
challengeName.name)
random.shuffle(questions)
return questions, challengeName.timeSecs
return None
def handle(self, *args, **options):
lex = Lexicon.objects.get(lexiconName='OWL2')
lengthCounts = json.loads(lex.lengthCounts)
for length in range(5, 10):
for prob in range(1, lengthCounts[str(length)], 1000):
ppk_low = alphProbToProbPK(prob, lex.pk, length)
ppk_high = alphProbToProbPK(prob + 999, lex.pk, length)
alphas = Alphagram.objects.filter(
probability_pk__range=(ppk_low, ppk_high))
f = open(
'../wordsdir/%ds__%05d_to_%05d.txt' %
(length, prob, len(alphas) + prob - 1), 'wb')
for alpha in alphas:
words = alpha.word_set.all()
f.write(alpha.alphagram)
for word in words:
f.write(' ' + word.word)
f.write('\n')
f.close()
def generateDailyChallengePks(self, challengeName, lex):
# capture number. first try to match to today's lists
m = re.match("Today's (?P<length>[0-9]+)s", challengeName.name)
if m:
wordLength = int(m.group('length'))
if wordLength < 2 or wordLength > 15: return None # someone is trying to break my server >:(
print 'Generating daily challenges', lex, wordLength
minP = 1
maxP = json.loads(lex.lengthCounts)[repr(wordLength)] # lengthCounts is a dictionary of strings as keys
r = range(minP, maxP+1)
random.shuffle(r)
r = r[:50] # just the first 50 elements for the daily challenge
print r
pks = [alphProbToProbPK(i, lex.pk, wordLength) for i in r]
return pks, WordwallsGame.dcTimeMap[wordLength]
return None
def create_wl_lists(i, lex):
"""Create word lists for words with length `i`."""
lengthCounts = json.loads(lex.lengthCounts)
numForThisLength = lengthCounts[str(i)]
minProbPk = alphProbToProbPK(1, lex.pk, i)
maxProbPk = alphProbToProbPK(numForThisLength, lex.pk, i)
nl = NamedList(lexicon=lex,
numQuestions=numForThisLength,
wordLength=i,
isRange=True,
questions=json.dumps([minProbPk, maxProbPk]),
name='The ' + friendlyNumberMap[i])
nl.save()
if i >= 7 and i <= 8:
# create 'every x' list
for p in range(1, numForThisLength+1, LIST_GRANULARITY):
minP = alphProbToProbPK(p, lex.pk, i)
maxP = alphProbToProbPK(
min(p + LIST_GRANULARITY - 1, numForThisLength), lex.pk, i)
nl = NamedList(
lexicon=lex,
numQuestions=maxP - minP + 1,
wordLength=i,
isRange=True,
questions=json.dumps([minP, maxP]),
name='%s (%s to %s)' % (friendlyNumberMap[i], p,
min(p + LIST_GRANULARITY - 1,
numForThisLength)))
nl.save()
print 'JQXZ', i
if i >= 4 and i <= 8:
pks = get_pks_by_condition(
minProbPk, maxProbPk,
lambda a: re.search(r'[JQXZ]', a))
nl = NamedList(lexicon=lex,
numQuestions=len(pks),
wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='JQXZ ' + friendlyNumberMap[i])
nl.save()
if i == 7:
# 4+ vowel 7s
pks = get_pks_by_condition(
minProbPk, maxProbPk,
lambda a: (len(re.findall(r'[AEIOU]', a)) >= 4))
nl = NamedList(lexicon=lex,
numQuestions=len(pks),
wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='Sevens with 4 or more vowels')
nl.save()
if i == 8:
# 5+ vowel 8s
pks = get_pks_by_condition(
minProbPk, maxProbPk,
lambda a: (len(re.findall(r'[AEIOU]', a)) >= 5))
nl = NamedList(lexicon=lex,
numQuestions=len(pks),
wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='Eights with 5 or more vowels')
nl.save()
if lex.lexiconName == 'CSW12':
pks = get_pks_by_word_condition(
minProbPk, maxProbPk,
lambda w: (w.get('symbols') == '#+'))
nl = NamedList(lexicon=lex,
numQuestions=len(pks),
wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='CSW12 ' + friendlyNumberMap[i] + ' not in CSW07')
nl.save()
pks = get_pks_by_word_condition(
minProbPk, maxProbPk,
lambda w: ('#' in w.get('symbols')))
nl = NamedList(lexicon=lex, numQuestions=len(pks), wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='CSW12 ' + friendlyNumberMap[i] + ' not in OWL2')
nl.save()
if lex.lexiconName == 'America':
pks = get_pks_by_word_condition(
minProbPk, maxProbPk,
lambda w: (w.get('symbols') == '+'))
nl = NamedList(lexicon=lex,
numQuestions=len(pks),
wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='America ' + friendlyNumberMap[i] + ' not in OWL2')
nl.save()
def create_wl_lists(i, lex):
"""Create word lists for words with length `i`."""
lengthCounts = json.loads(lex.lengthCounts)
numForThisLength = lengthCounts[str(i)]
minProbPk = alphProbToProbPK(1, lex.pk, i)
maxProbPk = alphProbToProbPK(numForThisLength, lex.pk, i)
nl = NamedList(lexicon=lex,
numQuestions=numForThisLength,
wordLength=i,
isRange=True,
questions=json.dumps([minProbPk, maxProbPk]),
name='The ' + friendlyNumberMap[i])
nl.save()
if i >= 7 and i <= 8:
# create 'every x' list
for p in range(1, numForThisLength+1, LIST_GRANULARITY):
minP = alphProbToProbPK(p, lex.pk, i)
maxP = alphProbToProbPK(
min(p + LIST_GRANULARITY - 1, numForThisLength), lex.pk, i)
nl = NamedList(
lexicon=lex,
numQuestions=maxP - minP + 1,
wordLength=i,
isRange=True,
questions=json.dumps([minP, maxP]),
name='%s (%s to %s)' % (friendlyNumberMap[i], p,
min(p + LIST_GRANULARITY - 1,
numForThisLength)))
nl.save()
print 'JQXZ', i
if i >= 4 and i <= 8:
pks = get_pks_by_condition(
minProbPk, maxProbPk,
lambda a: re.search(r'[JQXZ]', a))
nl = NamedList(lexicon=lex,
numQuestions=len(pks),
wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='JQXZ ' + friendlyNumberMap[i])
nl.save()
if i == 7:
# 4+ vowel 7s
pks = get_pks_by_condition(
minProbPk, maxProbPk,
lambda a: (len(re.findall(r'[AEIOU]', a)) >= 4))
nl = NamedList(lexicon=lex,
numQuestions=len(pks),
wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='Sevens with 4 or more vowels')
nl.save()
if i == 8:
# 5+ vowel 8s
pks = get_pks_by_condition(
minProbPk, maxProbPk,
lambda a: (len(re.findall(r'[AEIOU]', a)) >= 5))
nl = NamedList(lexicon=lex,
numQuestions=len(pks),
wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='Eights with 5 or more vowels')
nl.save()
if lex.lexiconName == 'CSW12':
pks = get_pks_by_word_condition(
minProbPk, maxProbPk,
lambda w: (w.get('symbols') == '#+'))
nl = NamedList(lexicon=lex,
numQuestions=len(pks),
wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='CSW12 ' + friendlyNumberMap[i] + ' not in CSW07')
nl.save()
pks = get_pks_by_word_condition(
minProbPk, maxProbPk,
lambda w: ('#' in w.get('symbols')))
nl = NamedList(lexicon=lex, numQuestions=len(pks), wordLength=i,
isRange=False,
questions=json.dumps(pks),
name='CSW12 ' + friendlyNumberMap[i] + ' not in OWL2')
nl.save()
def searchForAlphagrams(data, lex):
""" searches for alphagrams using form data """
length = int(data['wordLength'])
minP = alphProbToProbPK(data['probabilityMin'], lex.pk, length)
maxP = alphProbToProbPK(data['probabilityMax'], lex.pk, length)
return SearchDescription.probPkIndexRange(minP, maxP, lex)
