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)