def handle(self, *args, **options): Tag.objects.bulk_create([Tag(tag=t[0], slug=t[1]) for t in tags], ignore_conflicts=True) names = generate_username(int(options["num_users"])) User = get_user_model() users = [ User.objects.create_user(username=n, password=self.password) for n in names ] print(users) gen = DocumentGenerator() gen.init_word_cache(5000) gen.init_sentence_cache(5000) for user in users: user = User.objects.get(username=user.username) user.profile.bio = gen.sentence() user.profile.save() articles = Article.objects.bulk_create([ Article( slug=make_slug(gen.sentence()), title=gen.sentence(), description=gen.sentence(), body=gen.paragraph(), author=user.profile, ) # Make sure every user has at least 1 article for _ in range(random.randrange(1, self.article_upper_bound)) ]) print(articles) # Make sure every article has 1 tag, could add more later for article in articles: article.tags.add(Tag.objects.get(slug=random.choice(tags)[1])) self.stdout.write(self.style.SUCCESS(f"Created {len(users)} users"))
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 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 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")
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 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 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 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 handle(self, *args, **options): givers = [ Giver.objects.get_or_create(name='James'), Giver.objects.get_or_create(name='John'), Giver.objects.get_or_create(name='Robert'), Giver.objects.get_or_create(name='Michael'), Giver.objects.get_or_create(name='William'), Giver.objects.get_or_create(name='David'), Giver.objects.get_or_create(name='Richard'), Giver.objects.get_or_create(name='Joseph'), ] gen = DocumentGenerator() amount = options['amount'] if options['amount'] else 2500 for i in range(0, amount): dt = pytz.utc.localize(datetime.now() - timedelta(days=random.randint(0, 1825))) feedback = Feedback.objects.create( activity=random.choice(Feedback.ACTIVITIES)[0], giver=random.choice(givers)[0], complex=True if random.randint(1, 2) == 1 else False, complicated=True if random.randint(1, 2) == 1 else False, entrustability=random.choice(Feedback.ENTRUSTABILITY_SCORES)[0], done_well=gen.sentence(), needs_improvement=gen.sentence(), ) feedback.date = dt.date() feedback.save() self.stdout.write(self.style.SUCCESS('Successfully populated the database.'))
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 generate_pdf_params(): if not gen: gen = DocumentGenerator() randnum = random.randint(0, 100) name = str(uuid.uuid4()) text = "" if randnum < 25: text += ",".join( [gen.email() for i in range(random.randrange(100, 500))]) name += "email" elif randnum < 50: text += ",".join( [gen.phone() for i in range(random.randrange(100, 500))]) name += "phone" elif randnum < 75: text += ",".join( [gen.url() for i in range(random.randrange(100, 500))]) name += "url" else: text += ",".join( [gen.sentence() for i in range(random.randrange(100, 500))]) name += "words" return (name, ''.join([i if ord(i) < 128 else ' ' for i in text])), {}
def create_message(self): gen = DocumentGenerator() print("Creating Message") payload = {'content': gen.sentence(), "message_type": "incoming"} headers = { 'api_access_token': self.api_access_token, 'Content-type': 'application/json' } response = self.client.post("/api/v1/accounts/" + self.account_id + "/conversations/" + self.converation_id + "/messages", data=json.dumps(payload), headers=headers) if response.status_code == 200: json_response_dict = response.json() return str(json_response_dict['id']) else: try: print("response status code is: ", response.status_code) print("response body is: ", response.json()) raise Exception("Message Creation Failed") except Exception: raise Exception("Message Creation Failed")
def create_random_interactions(request): users = MyUser.objects.all() gen = DocumentGenerator() for user in users: create_post_probs = random.randint(1, 15) if create_post_probs == 1: text_content = gen.paragraph() Post.objects.create(user=user, text_content=text_content) for user in users: for person in user.followings.all(): person_posts = Post.objects.filter(user=person) for post in person_posts: like_post_probs = random.randint(1, 12) if like_post_probs == 1: post.liked_by.add(user) comment_post_probs = random.randint(1, 17) if comment_post_probs == 1: Comment.objects.create(post=post, user=user, content=gen.sentence()) return JsonResponse([], safe=False)
def obfuscating_payload(file_name): gen = DocumentGenerator() text = "#" + gen.sentence() with open(file_name, "a") as file: file.write(text)
def main(args): if len(args) == 0: print('need a file with dataset schemas') exit(0) ids = [] metadata = dict() with open(args[0], 'r') as dataset_metadata_file: metadata = json.load(dataset_metadata_file) graphql = config(section='graphql') rebloc = config(section='rebloc') headers = {'X-Hasura-Access-Key': graphql['apitoken']} _transport = RequestsHTTPTransport(url=graphql['endpoint'], headers=headers, use_json=True) graphql_client = Client(transport=_transport, fetch_schema_from_transport=True) my_marketplace = ReblocMarketplace(rebloc['endpoint'], graphql_client) ownerid = my_marketplace.look_up_user_id(rebloc['registeremail']) try: server_config = config(section='ipfs') gen = DocumentGenerator() seed = gen.sentence() print(seed) # 32 bytes encryption keys sample_key = hashlib.sha256( seed.encode('utf-8')).hexdigest()[:32].encode('utf8') print("key = %s" % sample_key) seed = gen.sentence() print(seed) # 32 bytes encryption keys data_key = hashlib.sha256( seed.encode('utf-8')).hexdigest()[:32].encode('utf8') print("key = %s" % data_key) # publish sample print('publishing sample....') data_file_path = metadata['file_path'] sample_info = publish_sample_data(sample_key, server_config['endpoint'], server_config['port'], data_file_path, sample_size=300) # publish full data print('publishing all data....') data_info = publish_all_data(data_key, server_config['endpoint'], server_config['port'], data_file_path) current_date_time = datetime.datetime.utcnow().strftime( "%a %b %d %H:%M:%S %Y") search_terms = "{permits,toronto}" default_ipfs_gateway = "http://demo-app.rebloc.io:8080/ipfs/" default_price = 0.5 if 0.00001 * metadata['num_of_records'] > default_price: default_price = round(0.01 * metadata['num_of_records'], 2) dataset = { "id": str(uuid.uuid1()), "name": metadata['name'], "table_name": "na", "description": metadata['description'], "country": "candada", "state_province": "ontario", "city": "{toronto}", "date_created": current_date_time, "date_modified": current_date_time, "dataset_owner_id": ownerid, "delivery_method": "IPFS", "enc_data_key": data_key.decode(), "enc_sample_key": sample_key.decode(), "sample_access_url": default_ipfs_gateway + sample_info['ipfs_hash'], "sample_hash": sample_info['md5_file_hash'], "access_url": default_ipfs_gateway + data_info['ipfs_hash'], 'data_hash': data_info['md5_file_hash'], "num_of_records": metadata['num_of_records'], "search_terms": search_terms, "topic": "{building}", "price_high": default_price, "price_low": 0.5, "stage": 3, "schema": metadata['schema'], "json_schema": json.dumps(metadata['schema']) } print(dataset) # list draft datasets to marketplace result = my_marketplace.post_draft_dataset(dataset) print(result) print('completed') except Exception as err: print("error occurs:%s" % err)
class RandomTweeter(Tweeter): def __init__(self): self._gen = DocumentGenerator() def get_tweet_text(self, tweet_id): return self._gen.sentence()
letter_in = letter_in.lower() if letter_in in alpha_a: position = alpha_a.index(letter_in) letter_out = alpha_b[position] if uppercase: sentence_out += letter_out.upper() else: sentence_out += letter_out else: sentence_out += letter_in return -key, sentence_out gen = DocumentGenerator() sentance_secret = gen.sentence() encryption_key, sentance_encrypted = encryption(sentance_secret) print('encrypted sentance is:\n', sentance_encrypted) guess = '' while guess != encryption_key: guess = int(input()) _, unencrypted_sentence = encryption(sentance_encrypted, guess) print(unencrypted_sentence) print('correct!')
# number of records per table record_per_table = int(sys.argv[1]) # generate Disaster data with open('data-pickles/disaster.pkl', 'wb') as f: disaster_data = list() unique_names = list() for id in tqdm(range(record_per_table)): while (True): name = generate_slug(random.randint(2, 4)) if name not in unique_names: unique_names.append(name) break disaster_data.append( [name, gen.sentence(), gen.sentence(), random.randint(1, 20)]) pickle.dump(disaster_data, f) # generate Incident data with open('data-pickles/incident.pkl', 'wb') as f: incident_data = list() for id in tqdm(range(record_per_table)): incident_data.append([ random.randint(1950, 2020), random.randint(1, 12), random.randint(1, 30), gen.sentence(), random.randint(1, 100000), generate_slug(3),
def generate_sentence(): gen = DocumentGenerator() return gen.sentence()
chrome_path += '/chromedriver' directory = "images" # open the chrome driver to google images driver = webdriver.Chrome(chrome_path) driver.get("https://images.google.com/") # generate a new word and search for it in the chrome driver word = getWord() search = driver.find_element_by_name("q") search.send_keys(word) # grab all of the image elements images = driver.find_elements_by_class_name("rg_i") # download one of the first 10 images num = random.randint(0, 10) img_url = images[num].get_attribute('src') images_path = os.path.join(directory, "image.jpg") ulib.urlretrieve(img_url, str(images_path)) # generate a sentence to be used in the caption gen = DocumentGenerator() sentence = gen.sentence() # log in to instagram and post the image and caption bot = Bot() bot.login(username=username, password=password) bot.upload_photo(str(images_path), caption=sentence)
elif prompt == "news_feed": # Get the news feed print_news_feed(username=token.username, api=api) elif prompt == "postrand": if token.username in [None, ""]: logging.error("Must login first") else: num_posts = input("#: ") if num_posts == "inf": num_submitted = 0 start_time = time() while True: try: p = Post(msg=gen.sentence(), username=token.username) post(p, api).result() num_submitted += 1 except KeyboardInterrupt: break end_time = time() print_time_report(time=end_time - start_time, num=num_submitted) else: num_posts = int(num_posts) num_threads = int(input("# threads: ")) pool = Pool(processes=num_threads) pieces = []
from tqdm import tqdm try: with open('config.json') as json_file: config = json.load(json_file) except: with open('default_config.json') as json_file: config = json.load(json_file) with open(config["dafont_file"]) as json_file: fonts = json.load(json_file) gen = DocumentGenerator() if not os.path.exists(config['data_path']): os.mkdir(config['data_path']) for font, ext in tqdm(fonts): folder_path = f"{config['data_path']}/{font}" if not os.path.exists(folder_path): os.mkdir(folder_path) n_files = len(os.listdir(folder_path)) # At the end we want exactly <number_of_sentences_per_font> images per font for _ in range(config["number_of_sentences_per_font"] - n_files): text = gen.sentence() url = f'https://img.dafont.com/preview.php?text={text}&ttf={font}&ext={ext}&size=50&psize=m&y=60)' response = requests.get(url, stream=True) with open(f"{folder_path}/{time()}.png", 'wb') as out_file: shutil.copyfileobj(response.raw, out_file) del response
# Setting up chrome driver options = webdriver.ChromeOptions() options.headless = False prefs = {"profile.default_content_setting_values.notifications", 2} driver = webdriver.Chrome(executable_path="Driver\chromedriver.exe", chrome_options=options) ############################################################################################## # Facebook Bot Flow # 1. Login # 2. Open account profile page # 3. Add a friend. # 4. Write a post from home page # 5. Open a random friends profile and write a post bot = Facebook_Bot(driver, config, friends) bot.login() # Logs into the facebook account bot.open_profile() # Opens the Profile Page bot.add_friend() # This Function helps to send a friend request. bot.write_post( gen.sentence()) # This Helps in posting a message on your profile # bot.open_friends_profile_randomly() # This functions Randomly chooses a friend in your friends list bot.post_on_friends_profile( gen.sentence()) # This opens a friends profile randomly and writes a post