def _create_users(self):
rn = RandomNicknames()
for name in rn.random_nicks(count=50):
username = '******' % (slugify(name), random.randrange(1, 99))
user = User.objects.create_user(username=username,
email='*****@*****.**' % username,
password='******')
logger.info('Created user: %s', user.username)
def get_dummy_badges(self, count=20):
rn = RandomNicknames()
badges, slugs = [], []
for name in rn.random_nicks(count=count):
name = '%s #%d' % (name, randrange(99))
slug = slugify(name)
slugs.append(slug)
badges.append(Badge(name=name, slug=slug, description=name))
return badges, slugs
def _create_badges(self):
rn = RandomNicknames()
for name in rn.random_nicks(count=20):
slug = slugify(name)
badge = Badge.objects.create(
name=name,
slug=slug,
description='Lorem ipsum dolor sit amet, consectetur adipisicing elit')
logger.info('Created badge: %s', badge.name)
def _create_users(self):
rn = RandomNicknames()
for name in rn.random_nicks(count=50):
username = '******' % (slugify(name), random.randrange(1, 99))
user = User.objects.create_user(
username=username,
email='*****@*****.**' % username,
password='******')
logger.info('Created user: %s', user.username)
def get_dummy_badges(self, count=20):
rn = RandomNicknames()
badges, slugs = [], []
for name in rn.random_nicks(count=count):
name = '%s #%d' % (name, randrange(99))
slug = slugify(name)
slugs.append(slug)
badges.append(Badge(name=name, slug=slug, description=name))
return badges, slugs
def _create_badges(self):
rn = RandomNicknames()
for name in rn.random_nicks(count=20):
slug = slugify(name)
badge = Badge.objects.create(
name=name,
slug=slug,
description=
'Lorem ipsum dolor sit amet, consectetur adipisicing elit')
logger.info('Created badge: %s', badge.name)
def __init__(self):
super().__init__()
self.username = self.get_element(By.CSS_SELECTOR, 'input[name="usernameRegisterPage"]')
self.email = self.get_element(By.CSS_SELECTOR, 'input[name="emailRegisterPage"]')
self.password = self.get_element(By.CSS_SELECTOR, 'input[name="passwordRegisterPage"]')
self.confirm_password = self.get_element(By.CSS_SELECTOR, 'input[name="confirm_passwordRegisterPage"]')
self.agree_button = self.get_element(By.CSS_SELECTOR, 'input[name="i_agree"]')
self.register_button = self.get_element(By.CSS_SELECTOR, '#register_btnundefined')
self.generate_email = RandomEmails()
self.generate_username = RandomNicknames()
def get_dummy_users(self, count=20):
rn = RandomNicknames()
users, usernames = [], []
for name in rn.random_nicks(count=count):
name = '%s #%d' % (name, randrange(99))
username = slugify(name)
usernames.append(username)
users.append(
User(username=username,
email='*****@*****.**' % username,
password='******'))
return (users, usernames)
def get_dummy_users(self, count=20):
rn = RandomNicknames()
users, usernames = [], []
for name in rn.random_nicks(count=count):
name = '%s #%d' % (name, randrange(99))
username = slugify(name)
usernames.append(username)
users.append(User(
username=username,
email='*****@*****.**' % username,
password='******'))
return (users, usernames)
def get_dummy_recipes(self, count=50):
rn = RandomNicknames()
recipes, slugs = [], []
for name in rn.random_nicks(count=count):
slug = slugify(name)
slugs.append(slug)
name = name.encode('ascii', 'ignore')
attrs = dict(name=name,
slug=slug,
description=name,
image=name,
user_queryset=User.objects.none())
recipes.append(type(name, (BaseRecipe, ), attrs))
return (recipes, slugs)
def get_dummy_recipes(self, count=50):
rn = RandomNicknames()
recipes, slugs = [], []
for name in rn.random_nicks(count=count):
slug = slugify(name)
slugs.append(slug)
name = name.encode('ascii', 'ignore')
attrs = dict(
name=name,
slug=slug,
description=name,
image=name,
user_queryset=User.objects.none())
recipes.append(type(name, (BaseRecipe,), attrs))
return (recipes, slugs)
class CreateAccount(PageBase):
new_username = ""
new_password = ""
def __init__(self):
super().__init__()
self.username = self.get_element(By.CSS_SELECTOR, 'input[name="usernameRegisterPage"]')
self.email = self.get_element(By.CSS_SELECTOR, 'input[name="emailRegisterPage"]')
self.password = self.get_element(By.CSS_SELECTOR, 'input[name="passwordRegisterPage"]')
self.confirm_password = self.get_element(By.CSS_SELECTOR, 'input[name="confirm_passwordRegisterPage"]')
self.agree_button = self.get_element(By.CSS_SELECTOR, 'input[name="i_agree"]')
self.register_button = self.get_element(By.CSS_SELECTOR, '#register_btnundefined')
self.generate_email = RandomEmails()
self.generate_username = RandomNicknames()
def enter_valid_details(self): # enters details to register
password = PASSWORD
username = self.generate_username.random_nicks()
email = self.generate_email.randomMail()
self.username.send_keys(username)
self.email.send_keys(email)
self.password.send_keys(password)
self.confirm_password.send_keys(password)
self.agree_button.click()
self.register_button.click()
return [username, password]
def fill_database(db_name: str, password: str):
"""
Fill in the database for car sharing company with some random data.
:param db_name: Database name
:param password: Database manager's password (user: postgres)
"""
global fake
global rw
global run
global conn
global cursor
fake = Faker()
rw = RandomWords()
run = RandomNicknames()
conn = psycopg2.connect(host='localhost',
dbname=db_name,
user='******',
password=password,
async=0)
cursor = conn.cursor()
fillDBwithRandomData(12)
cursor.close()
conn.close()
print('Database was filled with random data successfully!\n')
def generate_songs_file(
limit, artist_id_limit=1000000, popularity_limit=1000000):
"""
generates files like
1|Help|154681|The Beatles|25
"""
rw = RandomWords()
rn = RandomNicknames()
with open(songs_file, 'w+') as f:
for i in range(limit):
line = [str(i)]
# title
line.append(' '.join(rw.random_words(count=randint(1, 5))))
line.append(str(int(popularity_limit * betavariate(2, 5))))
# artist
line.append(' '.join(rn.random_nicks(count=randint(1, 3))))
line.append(str(randint(0, artist_id_limit)))
f.write('|'.join(line) + '\n')
def sample_project_data():
'''
Generates a sample project
'''
import random
from random_words import RandomNicknames, RandomWords
random_names = RandomNicknames()
random_words = RandomWords()
project = {}
project['project_id'] = random.randint(1000, 9999)
project['project_title'] = "{} {}".format(
random_names.random_nick(gender='f').capitalize(),
random_words.random_word().capitalize())
return project
def create(self, username, password, email):
user = User(username=username, email=email)
user.set_password(password)
user.save()
gender = random.choice('fmu')
nickname = RandomNicknames().random_nick(gender=gender)
profile = Profile(user=user, nickname=nickname)
profile.save()
return user
def generate_songs_file(limit,
artist_id_limit=1000000,
popularity_limit=1000000):
"""
generates files like
1|Help|154681|The Beatles|25
"""
rw = RandomWords()
rn = RandomNicknames()
with open(songs_file, 'w+') as f:
for i in range(limit):
line = [str(i)]
# title
line.append(' '.join(rw.random_words(count=randint(1, 5))))
line.append(str(int(popularity_limit * betavariate(2, 5))))
# artist
line.append(' '.join(rn.random_nicks(count=randint(1, 3))))
line.append(str(randint(0, artist_id_limit)))
f.write('|'.join(line) + '\n')
def sendMessage():
r = RandomWords()
rn = RandomNicknames()
# Create SQS client
sqs = boto3.client("sqs")
queue_url = "https://sqs.us-east-1.amazonaws.com/306784070391/test"
# Generate Random Title
title = r.random_word()
# Generate Random Author
author = rn.random_nick(letter="r", gender="m")
# Generate Random Number of Weeks
weeks = random.randint(0, 10)
weeksFinal = str(weeks)
# Send message to SQS queue
response = sqs.send_message(
QueueUrl=queue_url,
DelaySeconds=10,
MessageAttributes={
"Title": {
"DataType": "String",
"StringValue": title
},
"Author": {
"DataType": "String",
"StringValue": author
},
"WeeksOn": {
"DataType": "Number",
"StringValue": weeksFinal
},
},
MessageBody=("Information about current NY Times fiction bestseller."),
)
print(response["MessageId"])
return response["MessageId"]
def generate_usernames_logins_and_passwords():
print('Generating usernames..')
usernames = []
for _ in range(USERNAMES_COUNT):
usernames.append(names.get_first_name() + ' ' + names.get_full_name())
print('Generated usernames')
print('Generating logins..')
rn = RandomNicknames()
logins = []
for _ in range(USERNAMES_COUNT):
logins.append(rn.random_nick(gender='u'))
print('Generated logins')
print('Generating passwords..')
passwords = []
for _ in range(USERNAMES_COUNT):
passwords.append(''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(10)))
print('Generated passwords')
return usernames, logins, passwords
def generate():
print("Generating!")
result = []
for i in xrange(500):
gender = 'f' if random.randint(0, 1) == 0 else 'm'
result.append({
'id': i,
'name': RandomNicknames().random_nick(gender=gender),
'age': random.randint(0, 90),
'hobby': RandomWords().random_word()
})
return result
def generate_random_chats(message_count: int,
participants: int = 2,
chats_number: int = 1) -> List[Chat]:
rn = RandomNicknames()
li = LoremIpsum()
chats = []
# Weighted sentence length probability table
message_length_probability = \
[1] * 25 + \
[2] * 35 + \
[3] * 20 + \
[4] * 10 + \
[5] * 7 + \
[6] * 3
for chat_n in range(chats_number):
people = rn.random_nicks(count=participants)
dt = datetime.now()
messages = []
for i in range(message_count):
# Generate random time intervals between 10 seconds and 24 hours
secs = randint(10, 60 * 60 * 24)
dt = dt + timedelta(seconds=secs)
# chooses a random sender
sender = random.choice(people)
# generate random message:
sentences_number = random.choice(message_length_probability)
text = li.get_sentences(sentences_number)
messages.append(Message(sender, dt, text))
chats.append(Chat(f"RandomChat_{chat_n}", people, messages))
return chats
def __init__(self, creator: BunkUser, channel: TextChannel):
super().__init__(channel, creator)
self.random: RandomWords = RandomWords()
self.nicks: RandomNicknames = RandomNicknames()
self.renderer: HangmanRenderer = HangmanRenderer(channel)
self.phrase: List[List[str]] = []
self.flat_phrase: List[str] = []
self.guesses: List[str] = []
self.matches: List[str] = []
self.is_active = False
self.is_cancelled = False
self.is_win = False
self.is_loss = False
self.name = None
self.participants: List[BunkUser] = []
self.game_type: str = "Random word"
def add_into_table(cursor,
table_name,
fields,
min_av=None,
max_av=None,
bounds=None,
lines_amount=None,
verbose=False):
"""
:param cursor: cursor to database
:param table_name: name of fielded table
:param fields: dictionary that contains fields in keys and types in values
:param bounds: bounds for int fields
:param min_av: min amount of randomized lines
:param max_av: max amount of randomized lines
:return: pass
"""
rw = RandomWords()
rn = RandomNicknames()
if lines_amount == None:
if min_av == None or max_av == None:
raise Exception("nor lines_amount or min_av & max_av passed")
lines_amount = get_input_int(title="HOW MANY?[%d - %d]" %
(min_av, max_av),
min=min_av,
max=max_av)
print("generate %d lines for table %s..." % (lines_amount, table_name))
for i in range(0, lines_amount):
request = "insert into %s values(" % table_name
bi = 0
for field, partype in fields.items():
if partype == PINT:
MIN_B = bounds[bi][0]
MAX_B = bounds[bi][1]
request += "%d," % np.random.randint(MIN_B, MAX_B)
bi += 1
elif partype == PSTR:
MIN_B = bounds[bi][0]
MAX_B = bounds[bi][1]
word = get_random_word(rw, min_size=MIN_B, max_size=MAX_B)
request += "\'%s\'," % word
bi += 1
elif partype == PSEQ:
MIN_B = bounds[bi][0]
MAX_B = bounds[bi][1]
seq = ""
for i in range(MIN_B):
seq += get_random_word(rw, min_size=1, max_size=20) + " "
request += "\'%s\'," % seq[:seq.__len__() - 1]
bi += 1
elif partype == PREF:
(min_id, max_id, lines) = get_table_turp(cursor, field)
if min_id == 0 and max_id == 0:
raise Exception("table = %s is empty" % field)
currid = np.random.randint(low=min_id, high=max_id)
request += "%d," % lines[currid][0]
elif partype == PDATE:
request += "%s," % "current_date"
elif partype == PID:
rid = get_free_id(cursor, table_name)
request += "%d," % rid
elif partype == PNAME:
MIN_B = bounds[bi][0]
MAX_B = bounds[bi][1]
name = get_random_name(rn, min_size=MIN_B, max_size=MAX_B)
request += "\'%s\'," % name
bi += 1
request = request[:request.__len__() - 1] + ")"
if verbose: print(request)
cursor.execute(request)
pass
import logging
import time
from random_words import RandomNicknames
import odoo
_logger = logging.getLogger(__name__)
rn = RandomNicknames()
def execute(self):
odoo.cli.server.setup_pid_file()
website = self.env['website'].browse(1)
views = [
'website.404',
'website.layout',
'website.show_website_info',
'website.assets_backend',
'website.brand_promotion',
'portal.frontend_layout',
'portal.portal_show_sign_in',
'portal.record_pager',
'portal.portal_sidebar',
'web.webclient_bootstrap',
]
def __init__(self):
self.server_url = f'http://{server_ip}:{server_port}'
self.rw = RandomWords()
self.rn = RandomNicknames()
def setup_class(cls):
cls.rn = RandomNicknames()
cls.letters = 'qwertyuiopasdfghjklzxcvbnm'
import random
from config import count_tracks
from config import count_users
from random_words import RandomWords
from random_words import RandomNicknames
from models import User
from models import Track
rw = RandomWords() # класс отвечающий за случайные слова
rn = RandomNicknames() # класс отвечающий за случайный ник
tracks = [
Track(
' '.join(rw.random_words(
count=random.randint(1, 5))), # название из слов от 1 до 5
random.randint(1, 8), # размер в мб
random.randint(50, 300) # продолжительнос в с
) for t in range(count_tracks)
]
users = [
User(
rn.random_nick(gender='u'), # какой - то никнейм
random.randint(12, 50), # возраст
[random.choice(tracks) for _ in range(random.randint(5, 20))
] # какие-то случайные песни от 5 до 20
) for _ in range(count_users)
]
#!/usr/bin/env python
from asciimatics.widgets import Frame, ListBox, Layout, Divider, Text, Button, TextBox, Widget, PopUpDialog
from asciimatics.scene import Scene
from asciimatics.event import KeyboardEvent
from asciimatics.screen import Screen, ManagedScreen
from asciimatics.exceptions import ResizeScreenError, NextScene, StopApplication
import os
import sys
import subprocess
import libtmux as tm
from random_words import RandomNicknames
import psutil
rn = RandomNicknames()
def list_sessions():
sessions = []
for session in tm.Server().sessions:
attached = session['session_attached'] == '1'
if attached:
attached = "(*)"
else:
attached = "( )"
windows = int(session['session_windows'])
sessions.append(("{} {} [{}]".format(attached, session.name,
windows), session.name))
return sessions
class Command(BaseCommand):
for tag in tags: # creating independent tags
t = Tag(name=tag)
t.save()
tag_ids.append(t.pk)
for i in range(40): # creating users
u = User(username=RandomWords().random_word() +
str(random.randint(0, 99999)),
first_name=RandomNicknames().random_nick(gender='m'),
last_name=RandomNicknames().random_nick(gender='m'),
email=RandomEmails().randomMail(),
date_joined=random_date(d1, d2),
password=RandomWords().random_word())
u.save()
user_ids.append(u.pk)
for i in range(500): # create questions
q = Question(
head=LoremIpsum().get_sentence(),
content=LoremIpsum().get_sentences(5),
author_id=random.choice(user_ids),
date=random_date(d1, d2),
up_votes=random.randint(0, 50),
down_votes=random.randint(0, 50),
)
q.save()
question_ids.append(q.pk)
tags = random.sample(tag_ids, 4)
for tag in tags:
q.tags.add(tag)
for i in range(1800): # creating answers
a = Answer(
content=LoremIpsum().get_sentences(3),
question_id=random.choice(question_ids),
author_id=random.choice(user_ids),
date=random_date(d1, d2),
validity=random.choice([-1, 1]),
votes=random.randint(-50, 50),
)
a.save()
for i in range(3000): # views faker
q = QuestionView(
session=str(random.randint(1, 255)) + '.' +
str(random.randint(1, 255)) + '.' + str(random.randint(1, 255)) +
'.' + str(random.randint(1, 255)),
ip=str(random.randint(1, 255)) + '.' +
str(random.randint(1, 255)) + '.' + str(random.randint(1, 255)) +
'.' + str(random.randint(1, 255)),
question=Question.objects.get(id=random.choice(question_ids)),
created=random_date(d1, d2))
q.save()
for i in range(120):
b = Bookmark(
question=Question.objects.get(id=random.choice(question_ids)),
user=User.objects.get(id=random.choice(user_ids)),
)
b.save()
