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 _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 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 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 __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 _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 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 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 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 __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 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 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_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 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)
]
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()
