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
