def set_random_parameters(self):
self.name = '' if randint(0, 4) < 1 else utils.get_random_word(
alphabet, randint(3, 10))
self.header = '' if randint(0, 4) < 1 else utils.get_random_word(
alphabet + ' ', randint(10, 20))
self.footer = '' if randint(0, 4) < 1 else utils.get_random_word(
alphabet + ' ', randint(10, 20))
return self
def get_random_valid_answer(self) -> Optional[str]:
return get_random_word(
min_len=self.min_letters_limit,
starting_letter=self.current_word[-1],
required_letter=self.required_letter,
exclude_words=self.used_words,
)
def get_random_word(cls):
""" Returns a random word fetched from Wikipedia.
:return string
"""
random_word_text = utils.get_random_word()
word = cls(text=random_word_text)
word._load_data()
return word
async def running_initialization(self) -> None:
# Random starting word
self.current_word = get_random_word(min_len=self.min_letters_limit)
self.used_words.add(self.current_word)
self.start_time = datetime.now().replace(microsecond=0)
# No turn order
await self.send_message(
f"The first word is _{self.current_word.capitalize()}_.")
def random():
'''API to get random word'''
error, word = get_random_word()
if not error:
resp = make_response(200, {'word': word})
else:
resp = make_response(502, {'status': 'error', 'error': error})
return resp
def new_game(self, request):
""" Creates a new game """
user = User.query(User.name == request.user_name).get()
if not user:
raise endpoints.NotFoundException(
"A User with that name does not exist!")
game = Game.new_game(user.key,
get_random_word(request.difficulty),
request.difficulty)
return game.to_form("Good luck playing hangman!")
async def running_initialization(self) -> None:
# Random starting word
self.current_word = get_random_word(min_len=self.min_letters_limit)
self.used_words.add(self.current_word)
self.start_time = datetime.now().replace(microsecond=0)
await self.send_message(
f"The first word is <i>{self.current_word.capitalize()}</i>.\n\n"
"Turn order:\n" +
"\n".join([p.mention for p in self.players_in_game]),
parse_mode=types.ParseMode.HTML,
)
def __call__(self, instance):
is_next, tokens_a, tokens_b = instance
# -3 for special tokens [CLS], [SEP], [SEP]
truncate_tokens_pair(tokens_a, tokens_b, self.max_len - 3)
# Add Special Tokens
tokens = ['[CLS]'] + tokens_a + ['[SEP]'] + tokens_b + ['[SEP]']
segment_ids = [0] * (len(tokens_a) + 2) + [1] * (len(tokens_b) + 1)
input_mask = [1] * len(tokens)
# For masked Language Models
masked_tokens, masked_pos = [], []
# the number of prediction is sometimes less than max_pred when sequence is short
n_pred = min(self.max_pred,
max(1, int(round(len(tokens) * self.mask_prob))))
# candidate positions of masked tokens
cand_pos = [
i for i, token in enumerate(tokens)
if token != '[CLS]' and token != '[SEP]'
]
shuffle(cand_pos)
for pos in cand_pos[:n_pred]:
masked_tokens.append(tokens[pos])
masked_pos.append(pos)
if rand() < 0.8: # 80%
tokens[pos] = '[MASK]'
elif rand() < 0.5: # 10%
tokens[pos] = get_random_word(self.vocab_words)
# when n_pred < max_pred, we only calculate loss within n_pred
masked_weights = [1] * len(masked_tokens)
# Token Indexing
input_ids = self.indexer(tokens)
masked_ids = self.indexer(masked_tokens)
# Zero Padding
n_pad = self.max_len - len(input_ids)
input_ids.extend([0] * n_pad)
segment_ids.extend([0] * n_pad)
input_mask.extend([0] * n_pad)
# Zero Padding for masked target
if self.max_pred > n_pred:
n_pad = self.max_pred - n_pred
masked_ids.extend([0] * n_pad)
masked_pos.extend([0] * n_pad)
masked_weights.extend([0] * n_pad)
return (input_ids, segment_ids, input_mask, masked_ids, masked_pos,
masked_weights, is_next)
async def running_initialization(self) -> None:
self.start_time = datetime.now().replace(microsecond=0)
self.turns_until_elimination = len(self.players_in_game)
self.game_mode = random.choice(self.game_modes)
# First round is special since first word has to be set
# Set starting word and mode-based attributes
if self.game_mode is BannedLettersGame:
BannedLettersGame.set_banned_letters(self)
self.current_word = get_random_word(
banned_letters=self.banned_letters)
elif self.game_mode is ChosenFirstLetterGame:
# Ensure uniform probability of each letter as the starting letter
self.current_word = get_random_word(
starting_letter=random.choice(ascii_lowercase))
else:
self.current_word = get_random_word()
if self.game_mode is RequiredLetterGame:
RequiredLetterGame.change_required_letter(self)
self.used_words.add(self.current_word)
await self.send_message(
(f"The first word is <i>{self.current_word.capitalize()}</i>.\n\n"
"Turn order:\n" +
"\n".join([p.mention for p in self.players_in_game])),
parse_mode=types.ParseMode.HTML,
)
round_text = f"Round 1 is starting...\nMode: <b>{self.game_mode.name.capitalize()}</b>"
if self.game_mode is ChosenFirstLetterGame:
round_text += f"\nThe chosen first letter is <i>{self.current_word[0].upper()}</i>."
elif self.game_mode is BannedLettersGame:
round_text += f"\nBanned letters: <i>{', '.join(c.upper() for c in self.banned_letters)}</i>"
round_text += "\n\nLeaderboard:\n" + self.get_leaderboard()
await self.send_message(round_text, parse_mode=types.ParseMode.HTML)
def __call__(self, data):
is_next, tokens_a, tokens_b = data
truncate_tokens_pair(tokens_a, tokens_b, self.max_len - 3)
# Add Special Tokens
tokens = ['[CLS]'] + tokens_a + ['[SEP]'] + tokens_b + ['[SEP]']
segment_ids = [0] * (len(tokens_a) + 2) + [1] * (len(tokens_b) + 1)
input_mask = [1] * len(tokens)
# For masked Language Models
masked_tokens, masked_pos = [], []
n_pred = min(self.max_pred,
max(1, int(round(len(tokens) * self.mask_prob))))
cand_pos = [
i for i, token in enumerate(tokens)
if token != '[CLS]' and token != '[SEP]'
]
shuffle(cand_pos)
for pos in cand_pos[:int(n_pred)]:
masked_tokens.append(tokens[pos])
masked_pos.append(pos)
if rand() < 0.8: # 80%
tokens[pos] = '[MASK]'
elif rand() < 0.5: # 10%
tokens[pos] = get_random_word(self.indexer.vocab)
masked_weights = [1] * len(masked_tokens)
# Token Indexing
input_ids = self.indexer.convert_tokens_to_ids(tokens)
masked_ids = self.indexer.convert_tokens_to_ids(masked_tokens)
# Zero Padding
n_pad = self.max_len - len(input_ids)
input_ids.extend([0] * int(n_pad))
segment_ids.extend([0] * int(n_pad))
input_mask.extend([0] * int(n_pad))
# Zero Padding for masked target
if self.max_pred > n_pred:
n_pad = self.max_pred - n_pred
masked_ids.extend([0] * int(n_pad))
masked_pos.extend([0] * int(n_pad))
masked_weights.extend([0] * int(n_pad))
return (input_ids, segment_ids, input_mask, masked_ids, masked_pos,
masked_weights, is_next)
import data
import utils
word = utils.get_random_word(data.words)
chars = []
score = 0
pseudo = input('Your pseudo ? ')
last_core = utils.get_last_scores(pseudo)
if last_core:
print('Last score : ' + str(last_core))
while True:
hidden_word = utils.generate_hidden_word(word, chars)
print('hit ' + str(score) + '/' + str(data.nb_max_hit))
print('Hidden word : ' + hidden_word)
char = utils.get_input()
chars.append(char)
score += 1
if score > data.nb_max_hit:
print('The hidden word is : ' + word)
print('DEFEATE !!!')
break
def test_get_random_word(self, mock_get):
error, word = get_random_word()
self.assertEqual(error, None)
self.assertEqual(word, 'test')
def set_random_parameters(self):
# getrandbits(1) returns 0 or 1 with 50% probability
# with 50% probability generate random word on alphabet with random length
# and with probability 50% returns EMPTY_STRING
self.lastname = '' if bool(getrandbits(1)) else utils.get_random_word(
alphabet, randint(3, 10))
self.firstname = '' if bool(getrandbits(1)) else utils.get_random_word(
alphabet, randint(3, 10))
self.middlename = '' if bool(
getrandbits(1)) else utils.get_random_word(alphabet, randint(
3, 10))
self.nickname = '' if bool(getrandbits(1)) else utils.get_random_word(
alphabet, randint(3, 10))
# getrandbits(1) returns 0 or 1 with 50% probability
# with 50% probability generate random word on alphabet with random length
# and with probability 50% returns EMPTY_STRING
self.title = '' if bool(getrandbits(1)) else utils.get_random_word(
alphabet, randint(3, 10))
self.company = '' if bool(getrandbits(1)) else utils.get_random_word(
alphabet, randint(3, 10))
self.address = '' if bool(getrandbits(1)) else utils.get_random_word(
alphabet + ' ', randint(10, 20))
# 30% probability to be empty value
self.home = '' if randint(
0, 2) < 1 else '+7495' + utils.get_random_word(numbers, 7)
# 10% probability to be empty value
self.mobile = '' if randint(
0, 9) < 1 else '+79' + utils.get_random_word(numbers, 9)
# 50% probability to be empty value
self.work = '' if bool(
getrandbits(1)) else '+79' + utils.get_random_word(numbers, 9)
# 10% probability to be empty value
self.fax = '' if randint(
0, 9) < 1 else '+7495' + utils.get_random_word(numbers, 7)
# randint(0, 4) < 1 = 20%; randint(0, 4) < 4 = 80%
# with some probability generate random word on alphabet with random length
self.main = '' if randint(0,
4) < 1 else utils.get_random_email(alphabet)
self.secondary = '' if randint(
0, 4) < 4 else utils.get_random_email(alphabet)
self.other = '' if randint(0,
4) < 4 else utils.get_random_email(alphabet)
self.homepage = '' if bool(getrandbits(1)) \
else 'http://' + utils.get_random_word(alphabet, randint(3, 10)) + '.com'
start = datetime.date(1980, 1, 1)
end = datetime.date(2000, 12, 31)
bd = utils.get_random_date(start,
end) # get random date between given dates
if bool(getrandbits(1)): # 50% probability set birthdate
self.byear = bd.strftime('%Y') # get year from this date
self.bmonth = bd.strftime(
'%B') # get month in format April, January, ...
self.bday = str(
int(bd.strftime('%d'))
) # because %d is date with leading 0: 01, 02, 03, ... 11, 12, ...
if bool(getrandbits(
1)): # 50% probability to generate anniversary date
anniversary = utils.get_random_date(
bd, datetime.date.today()) # random date from BD to TODAY
self.ayear = anniversary.strftime('%Y')
self.amonth = anniversary.strftime('%B')
self.aday = str(int(anniversary.strftime('%d')))
# randint(0, 2) < 2 = 66%; getrandbits(1) returns 0 or 1 with 50% probability
# with some probability generate random word on alphabet with random length
self.address2 = '' if randint(0, 2) < 2 else utils.get_random_word(
alphabet + ' ', randint(10, 20))
self.phone = '' if randint(
0, 2) < 2 else '+7495' + utils.get_random_word(numbers, 7)
self.notes = '' if bool(getrandbits(1)) else utils.get_random_word(
alphabet + ' ', randint(10, 20))
return self
