def test_generate_paragraph(self):
"""Test loremipsum.generate_paragraph function."""
sentences, words, text = loremipsum.generate_paragraph()
self.assertEqual(sentences, len(list(self._s._find_sentences(text))))
self.assertEqual(words, len(list(self._s._find_words(text))))
sentences, words, text = loremipsum.generate_paragraph(paragraph_len=5)
self.assertEqual(sentences, 5)
def test_generate_paragraph(self):
"""Test loremipsum.generate_paragraph function."""
sentences, words, text = loremipsum.generate_paragraph()
self.assertEqual(sentences, len(list(self._s._find_sentences(text))))
self.assertEqual(words, len(list(self._s._find_words(text))))
sentences, words, text = loremipsum.generate_paragraph(paragraph_len=5)
self.assertEqual(sentences, 5)
def create(self):
'''
Loop through source emails and construct a fake email
'''
try:
self.src_mbox.lock()
self.dest_mbox.lock()
for msg in self.src_mbox:
fmsg = mailbox.mboxMessage()
fmsg.set_from('MAILER-DAEMON',
time_=self.extract_time(msg.get_from()))
for k, v in msg.items():
if k in ('To', 'From', 'Cc'):
fmsg[k] = self.anonomize(v)
elif k == 'Subject':
fmsg[k] = self.faker.company()
elif k == 'Date':
fmsg[k] = v
fmsg.set_payload(generate_paragraph()[-1])
self.dest_mbox.add(fmsg)
self.dest_mbox.flush()
finally:
self.src_mbox.unlock()
self.src_mbox.close()
self.dest_mbox.unlock()
self.dest_mbox.close()
def create (self):
'''
Loop through source emails and construct a fake email
'''
try:
self.src_mbox.lock()
self.dest_mbox.lock()
for msg in self.src_mbox:
fmsg = mailbox.mboxMessage()
fmsg.set_from('MAILER-DAEMON',time_=self.extract_time(msg.get_from()))
for k,v in msg.items():
if k in ('To', 'From', 'Cc'):
fmsg[k] = self.anonomize(v)
elif k =='Subject':
fmsg[k] = self.faker.company()
elif k == 'Date':
fmsg[k] = v
fmsg.set_payload(generate_paragraph()[-1])
self.dest_mbox.add(fmsg)
self.dest_mbox.flush()
finally:
self.src_mbox.unlock()
self.src_mbox.close()
self.dest_mbox.unlock()
self.dest_mbox.close()
def test_get_source(self):
end = generate_paragraph()[2]
httpretty.register_uri(httpretty.GET,
"https://word-search-engine.jorgechato.com",
body=end)
result = source.get_source("https://word-search-engine.jorgechato.com")
self.assertEqual(end, result, msg="Objects should be equals")
def setUp(self):
CustomUser.objects.create_user(
email='*****@*****.**',
first_name='Jack',
last_name='Nicholson',
password='******',
)
for i in range(3):
Post.objects.create(content=generate_paragraph()[2],
author=CustomUser.objects.first())
def setUp(self):
self.testdir = "/tmp/filestoretest/"
self.filestore = FileStore(self.testdir)
shutil.rmtree(self.testdir, True)
os.mkdir(self.testdir)
self.testfiles = []
for testfile in range(10):
testfile = join(self.testdir, "testfile%s.rst" % testfile)
self.testfiles.append(testfile)
with open(testfile, 'x') as testfile:
testfile.write(generate_paragraph()[2])
def vota():
"""
function of sending form. Lorem ipsum sent is random. Default parameters fit to common cases.
"""
br = mechanize.Browser()
br.open(link)
br.select_form(nr=0)
nome = br.form.controls[0].name
a, b, br[nome] = loremipsum.generate_paragraph()
# br[nome]='test'
br.submit()
br.close()
def perform():
while True:
file_name = join(
INPUT_PATH,
str(uuid5(NAMESPACE_DNS, str(datetime.now()))) + '.txt')
f = open(file_name, "w+")
for item in range(100):
_, _, paragraph = generate_paragraph()
f.write(paragraph)
f.close()
print("Created: ", file_name)
sleep(5)
def handle(self, *args, **options):
count = options['count']
for i in range(count):
news_content = ""
for j in range(random.randint(1, 4)):
news_content = news_content + generate_paragraph()[2] + "\n"
title = generate_sentence(start_with_lorem=True)[2]
if len(title) > 50:
title = title[0:50]
news = {
'content': news_content,
'content_pt': news_content,
'title': title,
'title_pt': title
}
News.objects.create(**news)
self.stdout.write("Created news number " + str(i))
def generate_sms_random():
timestamp = unix_time_millis(dt.now())
event_type = random.choice(list(event_type_set))
entity_type = random.choice(list(entity_type_set))
entity_id = random.randint(a=10000, b=99999)
event_name_list = filter(lambda x: event_type in x and entity_type in x,event_name_set)
farmer_id = random.randint(10001,10003)
if event_name_list:
event_name = random.choice(event_name_list)
else:
event_name = "order_create_email"
a,b,c = generate_paragraph()
event_details = dict(info="a", info_id='b', first=a,second=b, text=c)
event_dict = dict(eventType='sms', eventName=event_name, entityType=entity_type, entityId=entity_id,
eventDetails=event_details, timestamp=timestamp, farmerId=farmer_id)
return event_dict
def init_db(config=None, profiles_num=0):
app = create_app(config)
db = SqlDB()
db.init_app(app)
with app.app_context():
model.db.drop_all()
model.db.create_all()
for i in range(0, profiles_num):
p = UserProfileTable(firstName=names.get_first_name(),
lastName=names.get_last_name())
p.email = '{0}_{1}@gmail.com'.format(p.firstName, p.lastName).lower()
sentences_count, words_count, paragraph = generate_paragraph()
p.bio = paragraph[0:300]
with app.app_context():
db.add_profile(p)
print 'Created database with {0} profiles. '.format(profiles_num)
from default import db
from models import Institutes
from loremipsum import generate_paragraph, generate_sentence
#db.create_all()
# db.session.add(Institutes("a","b"))
# db.session.add(Institutes("a1","b"))
# db.session.add(Institutes("a2","b"))
# db.session.add(Institutes("a3","b"))
# db.session.add(Institutes("a4","b"))
# db.session.add(Institutes("a5","b"))
# db.session.add(Institutes("a6","b"))
# db.session.add(Institutes("a7","b"))
# db.session.add(Institutes("a8","b"))
# db.session.add(Institutes("a9","b"))
# db.session.add(Institutes("a10","b"))
# db.session.add(Institutes("a11","b"))
# db.session.add(Institutes("a12","b"))
# db.session.add(Institutes("a13","b"))
for i in range(0,1000):
a1,a2,title = generate_sentence()
b1,b2,paragraph = generate_paragraph()
db.session.add(Institutes(title,paragraph))
db.session.commit()
import riak
from loremipsum import generate_paragraph
import random
import string
client = riak.RiakClient(protocol='pbc', host='zx-riak-01.c.zetaops-academic-erp.internal', http_port=8087)
mybucket = client.bucket_type('sc').bucket('buket')
for i in range(1, 1000):
dd = '{"%s":"%s", "%s":"%s"}' % ("".join(random.choice(string.letters) for i in range(random.randint(3, 15))),
"".join(random.choice(string.letters) for i in range(random.randint(300, 1000))),
"".join(random.choice(string.letters) for i in range(random.randint(3, 15))),
generate_paragraph())
mybucket.new(data=dd).store()
def test_post_creation(self):
Post.objects.create(content=generate_paragraph()[2],
author=CustomUser.objects.first())
self.assertEqual(4, Post.objects.count())
path = 'scrap/dummy-collections/'
filename = "collection-" + str(random.randint(1000, 9999))
print filename
C = csv.writer(file(path + filename + ".csv", 'w'))
C.writerow(('content', 'META_sentences', 'META_words'))
J = {
"name": " ".join(LI.generate_sentence()[2].split()[:3]),
"description": LI.generate_sentence()[2],
"documents": []
}
for a in range(n):
sentences, words, text = LI.generate_paragraph()
row = (text, sentences, words)
C.writerow(row)
j = {
"content": text,
"metadata": {
"sentences": str(sentences),
"words": str(words),
}
}
J["documents"].append(j)
file(path + filename + ".json", 'w').write(json.dumps(J, indent=2))
if __name__ == '__main__': password = '******' from db import User, Story, addDefault, refresh_db, session as dbsession import random import loremipsum for adduser in range(1,1000): username = "******" % (adduser) user = User(username,'',password) user.species = 'Automatic' user.bio = 'Automatic bio' user.email = '*****@*****.**' user.minorflag = True user.accepttos =True dbsession.add(user) dbsession.commit() for addstories in range(1,20000): newstory = Story(loremipsum.generate_sentence()[2]) newstory.text = loremipsum.generate_paragraph()[2] newstory.adult = True newstory.uid = random.randrange(1000)+1 dbsession.add(newstory) dbsession.commit()
def random_text():
sentences_count, words_count, paragraph = generate_paragraph(5)
return paragraph
def random_paragraph():
_, _, paragraph = generate_paragraph()
return paragraph
path = 'scrap/dummy-collections/'
filename = "collection-"+str(random.randint(1000,9999))
print filename
C = csv.writer(file(path+filename+".csv", 'w'))
C.writerow(('content', 'META_sentences', 'META_words'))
J = {
"name": " ".join(LI.generate_sentence()[2].split()[:3]),
"description": LI.generate_sentence()[2],
"documents": []
}
for a in range(n):
sentences, words, text = LI.generate_paragraph()
row = ( text, sentences, words )
C.writerow(row)
j = {
"content" : text,
"metadata" : {
"sentences" : str(sentences),
"words" : str(words),
}
}
J["documents"].append(j)
file(path+filename+".json", 'w').write(json.dumps(J, indent=2))
dynamodb = boto3.resource("dynamodb", region_name='us-west-2')
messages = dynamodb.Table('messages')
messageBodys = dynamodb.Table('messagebody')
print("Sending 1000 messages to the server")
for i in range(1000):
# Create a random date
randomDay = random.randint(1, 28)
randomMonth = random.randint(1, 12)
randomYear = random.randint(2000, 2018)
date = str(randomYear) + "-" + str(randomMonth) + "-" + str(randomDay)
# Choose Recipient and Sender
recipient = random.choice(contacts)
sender = random.choice([x for x in contacts if x != recipient])
messages.put_item(
Item={
'recipient': recipient,
'date': date,
'sender': sender,
'subject': randomSubjects[i],
'msgId': str(i)
})
messageBodys.put_item(Item={
'msgId': str(i),
'msgBody': loremipsum.generate_paragraph()[2]
})
print("1000 messages sent")
def test_new_post(self):
post = Post(date=str(datetime.now()),
body=generate_paragraph()[2],
title=generate_sentence()[2])
r = self.loop.run_until_complete(self.controller.new_post(post))
assert r is True
user["password"] = generate_password_hash(user["password"])
user["role"] = "test"
r = requests.post(url, data=json.dumps(user), headers=headers)
resp = json.loads(r.content)
print resp
processed_users.append({"id": resp["_id"], "etag": resp["_etag"]})
print "---------------------------------Adding friends to users-----------------------"
print processed_users
uids = [x["id"] for x in processed_users]
for user in processed_users:
friends = set(random.sample(uids, int(random.random() * 10)))
friends - set([user["id"]])
headers["If-Match"] = user["etag"]
friends_dict = {}
friends_dict["friends"] = list(friends)
print friends_dict
print headers
r = requests.patch(url + "/" + user["id"], data=json.dumps(friends_dict), headers=headers)
print r.content
print "---------------------------------Adding posts to users-----------------------"
for user in processed_users:
for _ in range(20):
post = {}
post["type"] = "text"
post["author"] = user["id"]
post["content"] = generate_paragraph()[2]
r = requests.post(
url + "/" + user["id"] + "/posts", data=json.dumps(post), headers={"content-type": "application/json"}
)
print r.content
print '----------------------------user-------------------------'
print user
r = requests.post(url, data=json.dumps(user, default=json_util.default), headers=headers)
print '====================================================='
print r.content
resp = json.loads(r.content)
processed_users.append({'id': resp['_id'], 'etag': resp['_etag']})
print '---------------------------------Adding friends to users-----------------------'
print processed_users
uids = [x['id'] for x in processed_users]
for user in processed_users:
friends=set(random.sample(uids,int(random.random()*10)))
friends-set([user['id']])
headers['If-Match'] = user['etag']
friends_dict = {}
friends_dict['friends'] = []
print friends_dict
print headers
r = requests.patch(url + '/' + user['id'], data=json.dumps(friends_dict), headers=headers)
print r.content
print '---------------------------------Adding posts to users-----------------------'
for user in processed_users:
for _ in range(20):
post={}
post['type'] = 'text'
post['author'] = user['id']
post['content'] = generate_paragraph()[2]
r = requests.post(url + '/' + user['id'] + '/posts', data=json.dumps(post), headers={'content-type': 'application/json'})
print r.content
def randomMessage(self):
_, _, text = generate_paragraph()
return str(text).strip()
def test_article_creation(self):
Article.objects.create(title='Test Article',
content=generate_paragraph()[2],
author=CustomUser.objects.first())
self.assertEqual(4, Article.objects.count())
("highway", [("spending", True), ("demographics", True),
("eligibility", True), ("takeup", True), ("units", True),
("payroll", True), ("nonpayroll", True)]),
("transit", [("spending", True), ("demographics", True),
("eligibility", False), ("takeup", True), ("units", True),
("payroll", True), ("nonpayroll", True)])]
# lorem = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pellentesque eu, pretium quis, sem. Nulla consequat massa quis enim. Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu. In enim justo, rhoncus ut, imperdiet a, venenatis"
with open("templates/template.txt", "w") as f:
for c in cats:
cat = c[0]
cols = c[1]
for col in cols:
lorem = generate_paragraph()
while lorem[1] < 60 or lorem[1] > 70:
lorem = generate_paragraph()
if col[1]:
f.write("####### START_SECTION #######\n")
f.write("Category: %s\n" % cat)
f.write("Sorted by: %s\n\n" % col[0])
f.write("Top left State: DC\n")
f.write("Top left Column: spending\n\n")
f.write("Bottom right State: MD\n")
f.write("Bottom right Column: spending\n\n")
f.write("### Blurb text starts here ###\n")
f.write("%s\n" % lorem[2])
print '====================================================='
print r.content
resp = json.loads(r.content)
processed_users.append({'id': resp['_id'], 'etag': resp['_etag']})
print '---------------------------------Adding friends to users-----------------------'
print processed_users
uids = [x['id'] for x in processed_users]
for user in processed_users:
friends = set(random.sample(uids, int(random.random() * 10)))
friends - set([user['id']])
headers['If-Match'] = user['etag']
friends_dict = {}
friends_dict['friends'] = []
print friends_dict
print headers
r = requests.patch(url + '/' + user['id'],
data=json.dumps(friends_dict),
headers=headers)
print r.content
print '---------------------------------Adding posts to users-----------------------'
for user in processed_users:
for _ in range(20):
post = {}
post['type'] = 'text'
post['author'] = user['id']
post['content'] = generate_paragraph()[2]
r = requests.post(url + '/' + user['id'] + '/posts',
data=json.dumps(post),
headers={'content-type': 'application/json'})
print r.content
Uses @times and @ntimes decorators to time the total time of running each function 50 times.
Counter was consistantly the most performant of the three.
Example run: standard = 0.0159, default_dict = 0.0154, counter = 0.00903
Using Counter is also the most concise although not the most explicit in showing what's happening.
It does, however, have the benefit of most_common(n) method for easily selecting the n most common words.
Conclusion: I will use collections.Counter to perform iterable counts.
"""
import collections
import loremipsum
from helper_code.functions.decorators import timer, ntimes
_, _, TEST_PARAGRAPH = loremipsum.generate_paragraph()
TEST_LIST = TEST_PARAGRAPH.split()
@timer
@ntimes(50)
def standard():
"""Test standard way of using dictionary as word count."""
words = {}
for word in TEST_LIST:
if word in words:
words[word] += 1
else:
words[word] = 1
return words
