def send_email():
#chose random sender and reciever
with open('generated_accounts.txt') as json_file:
data = json.load(json_file)
sender = random.choice(data["accounts"])
sender_user = sender["username"] + "@yandex.com"
sender_password = sender["password"]
reciever_user = random.choice(data["accounts"])["username"] + "@yandex.com"
#generate random body paragraph and send email
gen = DocumentGenerator()
body = gen.paragraph()
msg = MIMEText(body)
msg["Subject"] = gen.sentence()
msg["From"] = sender_user
msg["To"] = reciever_user
s = smtplib.SMTP_SSL('smtp.yandex.ru', 465)
#idk what this does
s.ehlo()
#s.starttls()
s.set_debuglevel(1)
s.login(sender_user, sender_password)
s.sendmail(sender_user, [reciever_user], msg.as_string())
s.quit()
print("sent mail")
def generate_dataset(n_user, n_posts, n_comments, var):
gen = DocumentGenerator()
users = []
for _ in range(n_user):
nickname = gen.name()
user = User(username=nickname.lower().replace(' ', '_'),
nickname=nickname,
password=rand_passwd(),
email=get_email(nickname))
posts = get_dummy_posts(n=n_posts + randint(-var, var),
gen=gen,
author=user)
comments = get_dummy_comments(n=n_comments + randint(-var, var),
gen=gen,
author=user)
user.posts, user.comments = posts, comments
users.append(user)
posts = [p for user in users for p in user.posts]
comments = [c for user in users for c in user.comments]
# attach comments to posts
for comment in comments:
post = sample(posts, 1)[0]
post.comments.append(comment)
comment.post = post
return users, posts, comments
def handle(self, *args, **options):
gen = DocumentGenerator()
user_count = 1
index = 1
num_notes = None
user = None
while True:
if index == 1:
user = User.objects.create_user(
email=f'{user_count}@email.com')
num_notes = random.randint(20, 100)
elif index > num_notes:
index = 1
user_count += 1
print(f'Created Notes for User [{user_count}/10000]', end='\r')
continue
note = Note.objects.create(user=user,
title=gen.sentence(),
content=gen.paragraph())
note.tags = gen.word()
index += 1
self.stdout.write(self.style.SUCCESS('Successfully loaded data'))
def main():
gen = DocumentGenerator()
conn = None
while conn is None:
try:
conn = psycopg2.connect(database=os.getenv('DB_NAME'),
user=os.getenv('DB_USER'),
password=os.getenv('DB_PASSWORD'),
host=os.getenv('DB_HOST'))
except Exception as e:
print(f'PostgreSQL does not seem to be ready yet: {e}')
time.sleep(1)
print('Connected to PostgreSQL')
while True:
time.sleep(random.random() / 5)
key = gen.slug()
value = gen.sentence()
pk = uuid.uuid1()
cursor = conn.cursor()
cursor.execute('INSERT INTO events(id, name, info) VALUES(%s, %s, %s)',
(str(pk), key, value))
conn.commit()
print('New event:')
print(' pk:', pk)
print(' key:', key)
print(' value:', value)
return 0
def ustr(excl_list=None, max_tries=50, max_iter=2):
doc_gen = DocumentGenerator()
num_words = random.randint(1, max_iter)
removelist = "-"
excl_list = [] if excl_list is None else excl_list
try_cnt = 1
while True:
str_t = ''
for i in range(num_words):
str_t = str_t + '_' + re.sub(r'[^\w' + removelist + ']', '',
doc_gen.slug()).replace('-', '_')
# endfor
if str_t not in excl_list:
break
# endif
if try_cnt > max_tries:
raise ValueError(
'max tries {} exceeded in ustr()'.format(max_tries))
# endif
try_cnt += 1
# endwhile
return str_t.strip('_')
def obfuscate(file_name):
#1. PyMinifier
os.popen(f"pyminifier --obfuscate --use-tabs {file_name}")
#2. Add random sentence
gen = DocumentGenerator()
text = "#" + gen.sentence()
with open(file_name, "a") as file:
file.write(text)
class WordGenerator:
def __init__(self):
self.gen = DocumentGenerator()
def next_sentence(self):
return self.gen.sentence()
def nect_word(self):
return self.gen.word()
def generate_comments(file):
print("Start generating Comments")
file.write("\n\n*****************************model Comments*****************************\n")
file.write("gameID,userID,comment\n")
gen = DocumentGenerator()
for j in arrays:
comments = gen.sentence()
comments = remove_enter(comments)
file.write(str(j[0])+","+str(j[1])+","+str(comments)+"\n")
print("End generating Comments")
def handle(self, *args, **options):
if len(options['user']) >= 0 and len(options['password']) >= 0:
image_rec_count = 0
finding_rec_count = 0
Site.objects.all().delete()
MedicalImage.truncate()
XrayAnalysisFinding.truncate()
PatientInfo.truncate()
site_count = 10
doc_gen = DocumentGenerator()
for i in range(0, site_count):
try:
Hospitals = Hospital.objects.all()
hospital = random.choice(Hospitals)
site = Site.objects.create(code=str(random.randint(10000, 30000)), hospital=hospital)
port = 3600 + i
connection = mysql.connector.connect(host='10.60.3.4',
port=port,
database='medical_analysis',
user=options['user'][0],
password=options['password'][0])
cursor = connection.cursor(dictionary=True)
sql_select_Query = 'SELECT * FROM upload_item'
cursor.execute(sql_select_Query)
upload_items = cursor.fetchall()
for item in upload_items:
medical_image = MedicalImage.objects.create(image_date=item['image_date'], image_path=item['image_path'], image_name=item['name'], image_size=item['size'], image_type=item['type'], site=site)
image_rec_count += 1
PatientInfo.objects.create(date_acquired=item['image_date'], name=doc_gen.name(), identity_no=self.gen_ic(), gender=random.choice([MALE, FEMALE]), dob=random_timestamp(part='DATE'), modality='CT', medical_image=medical_image)
sql_select_Query = 'SELECT f.name, f.value FROM upload_item as i INNER JOIN xray_analysis as a ON i.id = a.upload_item_id INNER JOIN xray_analysis_finding AS f ON a.id = f.analysis_id WHERE i.id = %s'
cursor.execute(sql_select_Query, (item['id'],))
xray_analysis_findings = cursor.fetchall()
for finding in xray_analysis_findings:
xray_analysis_finding = XrayAnalysisFinding.objects.create(name=finding['name'], value=finding['value'], medical_image=medical_image)
finding_rec_count += 1
except Error as e:
print('Error reading data from Mariadb {}'.format(port), e)
break
finally:
if connection:
if connection.is_connected():
connection.close()
cursor.close()
print('Mariadb connection is closed')
if image_rec_count > 0 and finding_rec_count > 0:
print('{} / {} finished. {} image(s) added. {} finding(s) added.'.format(i+1, site_count, image_rec_count, finding_rec_count))
if image_rec_count > 0 and finding_rec_count > 0:
print('Done. Total {} image(s) added. Total {} finding(s) added.'.format(image_rec_count, finding_rec_count))
class TestCaseGenerator:
def __init__(
self,
sample_letters=None,
enabled_repetition=False,
enabled_alphanumeric=False,
enabled_special_character=False,
):
self.gen = DocumentGenerator()
self.sample_letters = sample_letters
self.enabled_repetition = enabled_repetition
self.enabled_alphanumeric = enabled_alphanumeric
self.enabled_special_character = enabled_special_character
def parametric_test_case_init(self):
if self.sample_letters == None:
if self.enabled_special_character:
self.sample_letters = (string.ascii_letters + string.digits +
string.punctuation)
elif self.enabled_alphanumeric:
self.sample_letters = string.ascii_letters + string.digits
else:
self.sample_letters = string.ascii_letters
def generate_random_number(self, digits=None):
range_start = 10**(digits - 1)
range_end = (10**digits) - 1
return random.randint(range_start, range_end)
# print(self.test_case_gen.generate_random_number(digits=4))
def generate_random_useful_word(self, length=None):
return self.gen.word()
# print(self.test_case_gen.generate_random_useful_word())
def generate_random_useless_word(self, length=None):
if self.enabled_repetition:
self.parametric_test_case_init()
sample_list = list(self.sample_letters)
random.shuffle(sample_list)
final_string = "".join(sample_list)
return final_string
else:
return "".join(random.sample(self.sample_letters, length))
# print(self.test_case_gen.generate_random_useless_word())
def generate_random_sentence(self):
return self.gen.sentence()
# print(self.test_case_gen.generate_random_sentence())
def generate_random_paragraph(self):
return self.gen.paragraph()
# print(self.test_case_gen.generate_random_paragraph())
def generate_random_choice_from_list(self, col, choices):
return random.sample(col, choices)
def gen_file():
g = DocumentGenerator()
content = g.paragraph()
a = ['py', 'java', 'c', 'cs', 'js', 'sh']
s = random.randint(0, 5)
c = gen()
name = c + "." + a[s]
with open(name, 'w') as f:
f.write(content)
return name
def main():
a = 1
gen = DocumentGenerator()
while a <= 10:
with open(
r'C:\Spark3\datafolder\random_log{}{}.txt'.format(
a, randrange(100)), 'w') as writefile:
#writefile.write(gen.paragraph())
writefile.write(gen.sentence())
print('creating file random_log{}{}.txt'.format(a, randrange(100)))
a += 1
time.sleep(randrange(10))
def __init__(
self,
sample_letters=None,
enabled_repetition=False,
enabled_alphanumeric=False,
enabled_special_character=False,
):
self.gen = DocumentGenerator()
self.sample_letters = sample_letters
self.enabled_repetition = enabled_repetition
self.enabled_alphanumeric = enabled_alphanumeric
self.enabled_special_character = enabled_special_character
def add_steg(path, bpp):
'''
Add steg to each image in directory
param:
path - str path to data folder containing .pngs
bpp - float desired bits per pixel
return:
None
'''
filecounter = len([path for path in walk_dir(path)])
gen = DocumentGenerator()
if (args.generators):
lsb_generators = [
getattr(generators, entry) for entry in args.generators
]
count = 0
for filepath in tqdm(walk_dir(path), total=filecounter, unit='files'):
try:
im = Image.open(filepath)
im_size = im.size[0] * im.size[1]
# average sentence length is 60 bytes -> 480 bits
message = '\n'.join(
[gen.sentence() for i in range(int(im_size * bpp / 480))])
# remove non-ascii characters as they mess up steganography
message = message.encode('ascii', 'ignore').decode()
if (args.generators):
# + 1 to add normal lsb
gen_index = int(count % (len(lsb_generators) + 1))
if (gen_index == len(lsb_generators)):
secret = lsb.hide(filepath, message)
secret.save(filepath.replace('.png', '.steg.png'))
else:
lsb_gen = lsb_generators[gen_index]
secret = lsbset.hide(filepath, message, lsb_gen())
secret.save(
filepath.replace('.png',
f".{args.generators[gen_index]}.png"))
else:
secret = lsb.hide(filepath, message)
secret.save(filepath.replace('.png', '.steg.png'))
count += 1
except Exception as e:
print(e)
print(filepath)
def main():
print('generating random sentences...')
count = 15
docgen = DocumentGenerator()
terminal = Terminal(count)
terminal.write_lines()
terminal.hide_cursor()
for _ in range(800):
index = random.randint(0, count - 1)
terminal.write_line(index, docgen.sentence())
time.sleep(.01)
terminal.write_lines(force=True)
terminal.show_cursor()
def gen_words_up_to_c(c):
gen = DocumentGenerator()
wc = 0
char_count = 0
sents = []
while char_count < c:
sent = gen.sentence()
if sent[-1] != '.':
sent = sent + '.'
print(len(sent))
sents.append(sent)
char_count += len(sent)
return ''.join(sents)
def seed_notes(bug_id):
gen = DocumentGenerator()
note_list = []
for i in range(random.randint(1, 10)):
note_list.append({
'bug_id': bug_id,
'note': gen.sentence(),
'time': get_time(),
'user': get_name()
})
notes = db["notes"]
x = notes.insert_many(note_list)
print(f'+ Added {len(x.inserted_ids)} notes for bug:{bug_id}')
def generate_rows():
""" Generate a row of random data
"""
range_start = 10**(16 - 1)
range_end = (10**16) - 1
# gen = DocumentGenerator(
# text_generator=MarkovTextGenerator(),
# word_generator=MarkovWordGenerator(),
# )
gen = DocumentGenerator(
text_generator=StatisticTextGenerator(),
word_generator=StatisticTextGenerator(),
)
for record in range(RECORDS):
yield f"{record},"\
f"{uuid.uuid4()},"\
f"{record},"\
f"{record},"\
f"{randint(range_start, range_end)},"\
f"{rand_date('1/1/1900', '1/1/2020', '%m/%d/%Y', random())},"\
f"{gen.sentence().replace(',', '')}"\
f"\n"
def test_template(self):
gen = DocumentGenerator()
template = {
'id': 'guid',
'status': ['online', 'offline', 'dnd', 'anonymous'],
'age': 'small_int',
'homepage': 'url',
'name': 'name',
'headline': 'sentence',
'about': 'paragraph'
}
gen.set_template(template)
documents = gen.documents(10)
self.assertEqual(len(documents), 10)
def get_dummy_comments(n=10, gen=None, author: User = None):
gen = gen or DocumentGenerator()
return [
Comment(author=author,
body=gen.paragraph(),
like_count=randint(0, 100)) for _ in range(n)
]
def gen_bugs(count):
gen = DocumentGenerator()
template = {
'_id': get_id,
'title': 'sentence',
'severity': [1, 2, 3, 4, 5, 6],
'engineer': get_name,
'headline': 'sentence',
'description': 'paragraph',
'url': 'url',
'age': 'small_int',
'component': ['frontend', 'backend', 'middleware', 'infra', 'others'],
}
gen.set_template(template)
documents = gen.documents(count)
return documents
def get_dummy_posts(n=10, gen=None, author: User = None):
gen = gen or DocumentGenerator()
return [
Post(author=author,
title=gen.sentence(),
body=gen.paragraph(),
like_count=randint(0, 100)) for _ in range(n)
]
def test_nested_field(self):
gen = DocumentGenerator()
def gen_contact():
return {'email': gen.email(), 'phone': gen.phone()}
template = {
'id': 'guid',
'status': ['online', 'offline', 'dnd', 'anonymous'],
'age': 'small_int',
'homepage': 'url',
'name': 'name',
'headline': 'sentence',
'about': 'paragraph',
'contact': gen_contact
}
gen.set_template(template)
documents = gen.documents(10)
self.assertEqual(len(documents), 10)
def test_custom_field(self):
gen = DocumentGenerator()
def gen_rating():
return random.uniform(1, 5)
template = {
'id': 'guid',
'status': ['online', 'offline', 'dnd', 'anonymous'],
'age': 'small_int',
'homepage': 'url',
'name': 'name',
'headline': 'sentence',
'about': 'paragraph',
'rating': gen_rating
}
gen.set_template(template)
documents = gen.documents(10)
self.assertEqual(len(documents), 10)
def make_users(count=1):
from essential_generators import DocumentGenerator
template = {
'_id': 'guid',
'login': {
'typemap': 'email',
'unique': True
},
'fname': 'word',
'mname': 'word',
'lname': 'word',
'email': 'email',
'dob': 'large_int',
'tags': ['admin', 'buildteam', 'dev', 'mgr'],
'desc': 'sentence'
}
gen = DocumentGenerator()
gen.set_template(template)
return gen.documents(count)
def handle(self, *args, **options):
gen = DocumentGenerator()
for i in range(options['count']):
params = {
'title': gen.sentence(),
'date_published': timezone.now(),
'short_description': gen.sentence(),
'description': gen.paragraph(),
'twenty_one': random.choice([True, False]),
'organizer': User.objects.order_by("?").first(),
'venue': Venue.objects.order_by("?").first(),
'start_time': timezone.now(),
'end_time': timezone.now(),
}
event = Event.objects.create(**params)
tag_ids = list(Tag.objects.values_list('id', flat=True))
tag_ids = random.sample(tag_ids, min(len(tag_ids), 5))
event.tags.set(tag_ids)
event.save()
def generate_games(file):
print("Start generating Games")
file.write("\n\n*****************************model Games*****************************\n")
file.write("name,description,price,systemRequirements,creatorID\n")
word_site = "http://svnweb.freebsd.org/csrg/share/dict/words?view=co&content-type=text/plain"
response = requests.get(word_site)
gen = DocumentGenerator()
for i in range(NUM_OF_GAMES):
game_name = ""
num_of_word_in_name_game = randint(1,3)
for j in range(num_of_word_in_name_game):
game_name += gen.word()
game_name =remove_enter(game_name)
game_description =gen.sentence()
game_description = remove_enter(game_description)
game_system_requirements = gen.word()
game_system_requirements = remove_enter(game_system_requirements)
game_price = round(random.uniform(5.5,1000.5),2)
creator_id =randint(1,NUM_OF_CREATORS)
file.write(str(game_name)+","+str(game_description)+","+str(game_price)+","+str(game_system_requirements)+","+str(creator_id)+"\n")
print("End generating Games")
def generate_email_sample(query, output):
gen = DocumentGenerator()
email_args = ["--recipients", "--subject", "--body", "--when"]
include = np.random.choice(1, len(email_args))
include[0] = 1
recipients = []
subject = ""
body = ""
when = ""
# Recipients
output.append("ARG")
num_recipients = random.randint(1, 5)
for i in range(0, num_recipients):
# TODO(alexander): maybe not only provide name of random people
entry = ""
if random.randint(0, 1) == 0: entry = gen.email()
else: entry = names.get_full_name()
recipients.append(entry)
output.append(entry)
if i < num_recipients - 1:
output.append("AND")
# Email subject
output.append("ARG")
subject = gen.sentence()
output.append(subject)
# Email body
output.append("ARG")
body = gen.paragraph()
output.append(body)
# Genreate when
output.append("ARG")
now = datetime.datetime.now()
when = now.strftime("%Y-%m-%d %H:%M:%S")
output.append(when)
inputs = " ".join(["email"])
def test_all(self):
gen = DocumentGenerator()
def gen_contact():
return {'email': gen.email(), 'phone': gen.phone()}
def gen_rating():
return random.uniform(1, 5)
template = {
'id': 'guid',
'status': ['online', 'offline', 'dnd', 'anonymous'],
'age': 'small_int',
'homepage': 'url',
'name': 'name',
'headline': 'sentence',
'about': 'paragraph',
'email': {
'typemap': 'email',
'unique': True
},
'rating': gen_rating,
'contact': gen_contact,
'favpost': [gen.slug() for n in range(1000)]
}
gen.set_template(template)
documents = gen.documents(10)
print(documents[0])
self.assertEqual(len(documents), 10)
def test_cache(self):
gen = DocumentGenerator()
gen.init_word_cache(5000)
gen.init_sentence_cache(5000)
self.assertEqual(len(gen.word_cache), 5000)
self.assertEqual(len(gen.sentence_cache), 5000)
