def generateNewsComponent():
wordCount = 24
newsComponent = html.Div(html.Div(children=[
html.Img(src="/assets/images/default.png",
alt="...",
className="img-rounded img-thumbnail"),
html.H4(lorem.words(5), className="card-title"),
html.H6("by " + lorem.words(2),
className="card-subtitle mb-2 text-muted"),
html.Hr(),
html.P(lorem.words(wordCount), className="card-text")
],
className="card-body"),
className="card w-25")
return newsComponent
def insert_post():
print('\n\nInserting a post')
req_headers = {
'Content-Type': 'application/json',
'Authorization': f'Bearer {token}'
}
global post_id
post = {
'title': lorem.words(random.randint(3, 7)),
'content_type': 'markdown',
'content': 'Define here the content you want in the post'
}
response = requests.post(f'http://{host}:{port}/api/posts',
headers=req_headers,
data=json.dumps(post))
# HTTP code 201 means "created"
assert response.status_code == 201, f'The webservice returned status code {response.status_code}!'
assert isinstance(response.json(),
dict), 'The webservice should return a JSON object.'
print('\tCreated with success')
post_received = response.json()
print('\tPost created:')
post_id = post_received['id']
print('\t\tid:', post_received['id'])
print('\t\ttitle:', post_received['title'])
def create_lorem_dict():
puppet_engineers = [puppet]
# generating lorem text for content dict
for title_id in content_template.keys():
if '_list' in title_id:
for x in range(randint(1, 4)):
content_template[title_id][1] += f'{lorem.sentence()}\n'
else:
content_template[title_id][1] = lorem.sentence()
# generating lorem text for info dict
for title_id in info_template.keys():
info_template[title_id][1] = lorem.words(randint(2, 5))
content_template['EHPW_line'][1] = '40 hrs/week'
info_template['DL'][1] = '30.10.2020'
info_template['CD'][1] = '27.10.2020'
info_template['PB'][1] = 'Alex'
return {
'content_dict': get_colored_titles(content_template),
'info_dict': info_template,
'engineers_list': puppet_engineers
}
def create_lorem_dict(proposal):
proposal.content_dict = get_template('content')
proposal.info_template = get_template('info')
content_template = proposal.content_dict
info_template = proposal.info_template
puppet = {
'N': ['Name', 'Puppet Vasya'],
'P': ['Position', 'QA engineer'],
'RT': ['Rate', '85'],
'EM': ['Email', '*****@*****.**'],
'PHT': ['Photo', '../engineers_photo/111.jpg']
}
puppet2 = {
'N': ['Name', 'Puppet Petya'],
'P': ['Position', 'Team lead'],
'RT': ['Rate', '45'],
'EM': ['Email', '*****@*****.**'],
'PHT': ['Photo', '../engineers_photo/222.jpg']
}
puppet3 = {
'N': ['Name', 'Puppet Anton'],
'P': ['Position', 'Project manager'],
'RT': ['Rate', '12'],
'EM': ['Email', '*****@*****.**'],
'PHT': ['Photo', '../engineers_photo/333.jpg']
}
puppet_engineers = [puppet, puppet2]
# generating lorem text for content dict
for title_id in content_template.keys():
if '_list' in title_id:
for x in range(randint(1, 4)):
content_template[title_id][1] += f'{lorem.sentence()}\n'
else:
content_template[title_id][1] = lorem.sentence()
# generating lorem text for info dict
for title_id in info_template.keys():
info_template[title_id][1] = lorem.words(randint(2, 5))
content_template['EHPW_line'][1] = '40 hrs/week'
info_template['DL'][1] = 'November 2, 2020'
info_template['CD'][1] = 'November 29, 2020'
info_template['PB'][1] = 'Alex'
proposal.content_dict = content_template
proposal.info_dict = info_template
print('CONTENT DICT BEFORE COLLORING :', proposal.content_dict)
return {
'content_dict': proposal.get_colored_titles(),
'info_dict': info_template,
'engineers_list': puppet_engineers
}
def test_comment_post():
posts = driver.find_elements_by_tag_name('article')
post = random.choice(posts)
post.find_element_by_class_name('article-title').click()
time.sleep(wait_time)
driver.find_element_by_id('content').send_keys(lorem.words(50))
driver.find_element_by_id('submit').click()
time.sleep(wait_time)
assert 'Your comment has been created' in driver.page_source
def main(words, s):
"""Console script for lorem."""
if words:
words = int(words)
click.echo(lorem.words(words))
# Returns a lorem ipsum sentence
elif s:
click.echo(lorem.sentence())
# Returns a lorem ipsum paragraph by default
else:
click.echo(lorem.paragraph())
def RandomCols(cols):
widths = np.random.random_sample(cols)
# Bootstrap col widths always sum up to 12
# Subtract cols from it since we're going to +1 after normalization
factor = (12 - cols) / sum(widths)
# Normalize numbers and +1 so we don't get widths of 0
widths = [int(width * factor) + 1 for width in widths]
# Need a fudge factor to fix rounding problems :)
fudge = 12 - int(sum(widths))
for _ in range(fudge):
widths[randint(0, len(widths))] += 1
# We have the widths that sum to 12, time to make them
for width in widths:
yield '<td class="col-{}">'.format(width)
yield lorem.words(randint(1, 10))
yield '</td>'
"tags": ["easy", "popular"],
"tutorials": [10],
"muscles": ["pec", "tri"],
},
{
"name": "pull ups",
"kind": "rep",
"instructions": "Tense your core during movement.",
"tags": ["medium", "popular"],
"tutorials": [20],
"muscles": ["lat", "bic", "sca"],
},
{
"name": "bulgarian split squat",
"kind": "rep",
"instructions": lorem.words(10),
"tags": ["legs"],
"tutorials": [21, 22, 23],
"muscles": ["qua", "glu"],
},
{
"name": "romanian single leg deadlift",
"kind": "rep",
"instructions": lorem.words(20),
"tags": ["legs"],
"muscles": ["ham", "lob"],
},
{
"name": "pistol squat",
"kind": "rep",
"instructions": lorem.words(30),
def handle(self, *args, **options):
# Remove all migrations and database file
path_migrations = "api/migrations"
for file in os.listdir(path_migrations):
if file != "__init__.py":
try:
os.remove(os.path.join(path_migrations, file))
except IsADirectoryError:
shutil.rmtree(os.path.join(path_migrations, file))
path_db = "db.sqlite3"
try:
os.remove(path_db)
except FileNotFoundError:
pass
# Recreate all tables
os.system("./manage.py makemigrations")
os.system("./manage.py migrate")
# Create superuser
superuser_command = (
"""from django.contrib.auth.models import User;""" +
"""User.objects.create_superuser('kmb', '*****@*****.**', 'test')""")
os.system(f'./manage.py shell -c "{superuser_command}"')
# Create users
u1 = User.objects.create_user("test",
"*****@*****.**",
password="******",
first_name="Test",
last_name="Smith")
u1.profile.date_of_birth = datetime.date(1990, 1, 10)
u1.profile.country = "Poland"
u1.profile.city = "Warsaw"
u1.profile.gender = "m"
u1.profile.save()
u2 = User.objects.create_user("test2",
"*****@*****.**",
password="******",
first_name="Diana",
last_name="Davis")
u2.profile.city = "New York"
u2.profile.gender = "f"
u2.profile.save()
# Create tags
tagnames = (
"easy",
"medium",
"hard",
"core",
"legs",
"arms",
"strength",
"mobility",
"endurance",
"popular",
)
for tagname in tagnames:
Tag(name=tagname).save()
# Create youtube videos
CHARSET = string.ascii_letters + string.digits
for i in range(100):
video_code = "".join(random.choices(CHARSET, k=7))
YoutubeLink(
url=f"https://www.youtube.com/watch?v={video_code}").save()
# Create muscles
for muscle_abbrev, muscle_name in Muscle.MUSCLES:
Muscle(name=muscle_abbrev).save()
# Create exercises for user with pk: 2
user = User.objects.get(pk=2)
for exercise_dict in EXERCISES_USER_1:
create_exercise(**exercise_dict, owner=user)
# Create routines for user with pk: 2
r = Routine.objects.create(
name="Leg workout A",
kind="sta",
instructions="This is the first leg workout.",
owner=user,
)
leg_exercises = Exercise.objects.filter(name__in=[
"bulgarian split squat",
"romanian single leg deadlift",
"pistol squat",
"lunges",
"box jumps",
])
r.exercises.set(leg_exercises, through_defaults={"sets": 3})
r = Routine.objects.create(
name="Leg workout B",
instructions="My favourite leg workout.",
kind="cir",
owner=user,
)
leg_exercises = Exercise.objects.filter(name__in=("bridge",
"hip thrust",
"step ups",
"jogging"))
instructions = [lorem.words(n) for n in (5, 10, 20, 40)]
for exercise, instruction in zip(leg_exercises, instructions):
r.exercises.add(exercise,
through_defaults={
"sets": 4,
"instructions": instruction
})
Routine.objects.create(name="Push A",
kind="sta",
owner=user,
forks_count=11)
Routine.objects.create(name="Push B", kind="sta", owner=user)
Routine.objects.create(name="Push C", kind="sta", owner=user)
Routine.objects.create(name="Push D", kind="sta", owner=user)
Routine.objects.create(name="Pull A",
kind="sta",
owner=user,
forks_count=3)
Routine.objects.create(name="Pull B",
kind="sta",
owner=user,
forks_count=2)
Routine.objects.create(name="Pull C", kind="sta", owner=user)
Routine.objects.create(name="Pull D", kind="sta", owner=user)
Routine.objects.create(name="FBW A",
kind="sta",
owner=user,
forks_count=1)
Routine.objects.create(name="FBW B", kind="sta", owner=user)
Routine.objects.create(name="FBW C", kind="sta", owner=user)
Routine.objects.create(name="FBW D", kind="sta", owner=user)
for i in range(30):
Routine.objects.create(name=f"Routine {i}", kind="sta", owner=user)
# Create exercises for user with pk: 3
user = User.objects.get(pk=3)
Exercise(name="bench press", kind="rew", owner=user).save()
Exercise(name="planche", kind="tim", owner=user).save()
Exercise(name="diamond push ups", kind="rep", owner=user).save()
Exercise(name="pike push ups", kind="rep", owner=user).save()
Exercise(name="archer push ups", kind="rep", owner=user).save()
Exercise(name="sphinx push ups", kind="rep", owner=user).save()
Exercise(name="hindu push ups", kind="rep", owner=user).save()
Exercise(name="one arm push ups", kind="rep", owner=user).save()
Exercise(name="push ups", kind="rep", owner=user).save()
Exercise(name="pull ups", kind="rep", owner=user).save()
ex = Exercise(
name="plank",
kind="tim",
instructions="Arms should be straight.",
owner=user,
)
ex.save()
ex.tutorials.set(
[YoutubeLink.objects.all()[60],
YoutubeLink.objects.all()[61]])
ex.muscles.set([Muscle.objects.get(name="abs")])
# Create routines for user with pk:
Routine.objects.create(name="Chest, triceps and shoulders",
kind="sta",
owner=user)
Routine.objects.create(name="Arms", kind="cir", owner=user)
Routine.objects.create(name="Upper body (bodyweight)",
kind="sta",
owner=user)
Routine.objects.create(name="Upper body (weights)",
kind="sta",
owner=user)
Routine.objects.create(name="Powerlifting",
kind="sta",
owner=user,
forks_count=3)
Routine.objects.create(name="Begginers",
kind="sta",
owner=user,
forks_count=2)
Routine.objects.create(name="Advanced abs", kind="sta", owner=user)
Routine.objects.create(name="Quads, hamstrings",
kind="sta",
owner=user)
Routine.objects.create(name="Endurance",
kind="sta",
owner=user,
forks_count=1)
Routine.objects.create(name="Full body", kind="cir", owner=user)
Routine.objects.create(name="Strenght", kind="sta", owner=user)
Routine.objects.create(name="Hypertrophy", kind="sta", owner=user)
def __call__(self) -> typing.Dict[str, ElementType] | None:
class_spec = self.mutator.factory.get_class_spec(
self.element_type.make())
if (len(self.before.keys()) == 0):
self.weights['clear'] = 0
self.weights['modify'] = 0
self.weights['pop'] = 0
self.weights['make.replace'] = 0
self.weights['pick.replace'] = 0
if (self.keys is not None
and len(self.keys) == len(self.before.keys())):
self.weights['make.insert'] = 0
self.weights['pick.insert'] = 0
chosen_kind = weighted_random(list(self.weights.keys()),
lambda key: self.weights[key])
if chosen_kind == 'clear':
location = source_code.Line()
self.mutator.push_strategy(location)
self.after = dict()
self.mutator.pop_strategy(location)
elif chosen_kind == 'modify':
if len(self.before.keys()) == 0:
raise RuntimeError('Logic error')
location = source_code.Line()
self.mutator.push_strategy(location)
chosen_key = random.choice(list(self.before.keys()))
self.after = dict(self.before)
with self.mutator.modify(self.before[chosen_key]) as ancestor:
self.after[chosen_key] = typing.cast(ElementType,
ancestor.target)
self.mutator.pop_strategy(location)
elif chosen_kind == 'pop':
if len(self.before.keys()) == 0:
raise RuntimeError('Logic error')
location = source_code.Line()
self.mutator.push_strategy(location)
chosen_key = random.choice(list(self.before.keys()))
self.after = dict(self.before)
del self.after[chosen_key]
self.mutator.pop_strategy(location)
elif chosen_kind == 'make.replace' or chosen_kind == 'make.insert':
location = source_code.Line()
self.mutator.push_strategy(location)
if chosen_kind == 'make.replace':
if len(self.before.keys()) == 0:
raise RuntimeError('Logic error')
chosen_key = random.choice(list(self.before.keys()))
elif self.keys is not None:
chosen_key = random.choice(
[key for key in self.keys if key not in self.before])
else:
chosen_key = lorem.words(1)
self.after = dict(self.before)
with self.mutator.make(class_spec) as ancestor1:
with self.mutator.modify(ancestor1.target) as ancestor2:
self.after[chosen_key] = typing.cast(
ElementType, ancestor2.target)
self.mutator.pop_strategy(location)
elif chosen_kind == 'pick.replace' or chosen_kind == 'pick.insert':
location = source_code.Line()
self.mutator.push_strategy(location)
if chosen_kind == 'pick.replace':
if len(self.before) == 0:
raise RuntimeError('Logic error')
chosen_key = random.choice(list(self.before.keys()))
elif self.keys is not None:
chosen_key = random.choice(
[key for key in self.keys if key not in self.before])
else:
chosen_key = lorem.words(1)
self.after = dict(self.before)
with self.mutator.pick(class_spec) as ancestor1:
with self.mutator.modify(ancestor1.target) as ancestor2:
self.after[chosen_key] = typing.cast(
ElementType, ancestor2.target)
self.mutator.pop_strategy(location)
else:
raise RuntimeError(f'Unsupported method {chosen_kind}')
return self.after
def generate_run_results(start_date: datetime, num_tests: int):
_test_suites = []
cur_time = start_date
start_time = cur_time
for suite_i in range(randint(4, 25)):
cur_time += timedelta(seconds=randint(0, 4)) # overhead
cur_time = cur_time.replace(microsecond=0)
elapsed_suite = 0
test_cases = []
for case_i in range(int(num_tests / 10)):
elapsed = randint(5, 60 * 10)
elapsed_suite += elapsed
cur_time += timedelta(seconds=elapsed)
# Add some randomization
choices = ['pass'] * randint(10, 70) + ['error'] * randint(
0, 20) + ['skipped'] * randint(0, 5) + ['failure'] * randint(
0, 5)
while len(choices) < 100:
choices.append(
random.choice(('pass', 'error', 'skipped', 'failure')))
status = random.choice(choices)
properties = {}
for i in range(randint(0, 10)):
properties[f'key{i}'] = f'value{i}'
test_case = TestCase(
system_err=[
Pair(tag='system-err', text=lorem.words(randint(1, 5)))
for _ in range(randint(0, 4))
],
system_out=[
Pair(tag='system-out', text=lorem.words(randint(1, 5)))
for _ in range(randint(0, 4))
],
properties=properties,
skipped=[] if status != 'skipped' else [
SimpleField(tag='skipped',
type=lorem.words(1),
message=lorem.words(randint(2, 15)),
text=lorem.words(randint(1, 5)))
for _ in range(randint(0, 4))
],
error=[] if status != 'error' else [
SimpleField(tag='error',
type=lorem.words(1),
message=lorem.words(randint(2, 15)),
text=lorem.words(randint(1, 5)))
for _ in range(randint(0, 4))
],
failure=[] if status != 'failure' else [
SimpleField(tag='failure',
type=lorem.words(1),
message=lorem.words(randint(2, 15)),
text=lorem.words(randint(1, 5)))
for _ in range(randint(0, 4))
],
rerun_failure=[],
rerun_error=[],
flaky_failure=[],
flaky_error=[],
attributes={
'name': f'test_case_{suite_i}_{case_i}',
'description': lorem.paragraph(),
'time': f'{elapsed:.3f}',
'classname':
f'my.package.test_case_class_{suite_i}_{case_i}',
'group': f'Group {suite_i}_{case_i}',
'file': f'test_suites/test_suite{suite_i}.py',
'line': 1 + suite_i * 100 + case_i,
})
test_cases.append(test_case)
properties = {}
for i in range(randint(0, 5)):
properties[f'key{i}'] = f'value{i}'
test_suite = TestSuite(
system_err=[
Pair(tag='system-err', text=lorem.words(randint(2, 10)))
for _ in range(randint(0, 4))
],
system_out=[
Pair(tag='system-out', text=lorem.words(randint(2, 10)))
for _ in range(randint(0, 4))
],
properties=properties,
testcases=test_cases,
attributes={
'name': f'test_suite_{suite_i}',
'description': lorem.words(randint(2, 10)),
'tests': str(len(test_cases)),
'failures':
str(len([e for e in test_cases if len(e.failure) > 0])),
'errors': str(len([e for e in test_cases
if len(e.error) > 0])),
'group': f'Group {suite_i}',
'time': f'{elapsed_suite:.3f}',
'skipped':
str(len([e for e in test_cases if len(e.skipped) > 0])),
'timestamp': cur_time.isoformat(),
'hostname': 'localhost',
'id': str(suite_i + 1),
'package': f'my.package{suite_i}',
'file': f'test_suites/test_suite{suite_i}.py',
'log': f'log_{suite_i}.log',
'url': f'http://some_url/suite{suite_i}',
'version': 'v1',
})
_test_suites.append(test_suite)
time = (cur_time - start_time).total_seconds()
test_suites = etree.Element(
'testsuites',
attrib={
'name':
'test_run',
'time':
f'{time:.3f}',
'tests':
str(sum([len(e.testcases) for e in _test_suites])),
'failures':
str(sum([int(e.attributes['failures']) for e in _test_suites])),
'errors':
str(sum([int(e.attributes['errors']) for e in _test_suites])),
})
for ts in _test_suites:
test_suites.append(ts.serialize())
return test_suites
def generate_title_name():
word_count = random.randint(4, 8)
return lt.words(word_count)
def loremtext(request):
text = "nothing"
if request.method == "POST":
words = int(request.POST.get('words', ''))
text = lorem.words(words)
return render(request, 'creative/lorem.html', {'text': text})
column_mapper_key_large_text = "large_text"
column_mapper_key_bool = "is_big"
column_mapper_key_float = "area",
column_mapper_key_tuple = "leaders"
column_mapper_key_dict = "city_hall"
column_mapper_values = [
{
column_mapper_key_id: "01002",
column_mapper_key_city: "CUSHMAN",
column_mapper_key_pop: 36963,
column_mapper_key_state: "MA",
column_mapper_key_loc: [
-72.51565, 42.377017
],
column_mapper_key_large_text: lorem.words(255),
column_mapper_key_bool: True,
column_mapper_key_float: 1352374687.06598,
column_mapper_key_tuple: ("wefwef", "wefwef", "wefwef"),
column_mapper_key_dict: {
"name": "home",
"stories": 3
}
},
{
column_mapper_key_id: "01003",
column_mapper_key_city: "CUSHMAN",
column_mapper_key_pop: 36934,
column_mapper_key_state: "OH",
def get_random_title():
return lorem.words(random.randrange(1, 4, 1)).upper()
def build_deck():
url = "deck/create/add_to_db"
data = {
"r1": words(2),
"r2": words(2),
"r3": words(2),
"r4": words(2),
"r5": words(2),
"p1": words(2),
"p2": words(2),
"p3": words(2),
"p4": words(2),
"p5": words(2),
"a1": words(2),
"a2": words(2),
"a3": words(2),
"a4": words(2),
"a5": words(2),
"f1": words(2),
"f2": words(2),
"f3": words(2),
"f4": words(2),
"f5": words(2),
}
response = client.post(url, data)
return response
def reload_database():
exit_reload = False
try:
response = requests.get(f'http://{host}:{port}')
app.logger.critical(
'The website seems to be running. Please stop it and run this file again.'
)
exit_reload = True
except:
pass
if exit_reload:
exit(11)
try:
os.remove('stock_analysis/site.db')
app.logger.info('previous DB file removed')
except:
app.logger.info('no previous DB file found')
assert not os.path.exists(
'stock_analysis/site.db'
), 'It seems that site.db was not deleted. Please delete it manually!'
db.create_all()
# creating two users
hashed_password = bcrypt.generate_password_hash('testing').decode('utf-8')
default_user1 = User(username='******',
email='*****@*****.**',
image_file='another_pic.jpeg',
password=hashed_password)
db.session.add(default_user1)
hashed_password = bcrypt.generate_password_hash('testing2').decode('utf-8')
default_user2 = User(username='******',
email='*****@*****.**',
image_file='7798432669b8b3ac.jpg',
password=hashed_password)
db.session.add(default_user2)
hashed_password = bcrypt.generate_password_hash('testing3').decode('utf-8')
default_user3 = User(username='******',
email='*****@*****.**',
password=hashed_password)
db.session.add(default_user3)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
app.logger.critical('Error while committing the user insertion.')
app.logger.exception(e)
# testing if the users were added correctly
def random_char(y):
return ''.join(random.choice(string.ascii_letters) for x in range(y))
assert len(
User.query.all()) == 3, 'It seems that user failed to be inserted!'
users = [default_user1, default_user2, default_user3]
stock_1 = Stock(name='INVESTOR',
number_of_shares=random.randint(1, 100000),
ticker=random_char(4).upper())
db.session.add(stock_1)
stock_2 = Stock(name='HELLO',
number_of_shares=random.randint(1, 1000000),
ticker=random_char(4).upper())
db.session.add(stock_2)
stock_3 = Stock(name='NIBE',
number_of_shares=random.randint(1, 1000000),
ticker=random_char(4).upper())
db.session.add(stock_3)
stocks = [stock_1, stock_2, stock_3]
try:
db.session.commit()
except Exception:
db.session.rollback()
app.logger.critical('Error while committing the user insertion.')
app.logger.exception()
for stock in stocks:
for user in users:
for a in range(random.randint(1, 10)):
# picking a random date for the analysis
random_date = datetime.datetime.now() - \
datetime.timedelta(days=random.randint(1, 90),
hours=random.randint(1, 23),
minutes=random.randint(1, 59))
# creating a random analysis
analysis = Analysis(title=lorem.words(random.randint(3, 10)),
content=lorem.words(random.randint(3, 20)),
date_posted=random_date,
price=random.randint(1, 1000),
earnings=random.randint(1, 100000),
p_e=random.randint(-5, 20),
market_cap=random.randint(1, 10000),
user=user,
stock=stock)
db.session.add(analysis)
diagram = Diagram(date=random_date,
stock=stock,
price=random.randint(1, 1000))
db.session.add(diagram)
try:
db.session.commit()
app.logger.info('Finalized - database created successfully!')
except Exception as e:
db.session.rollback()
app.logger.critical('The operations were not successful.')
app.logger.exception(e)
def Lorem(num_of_words):
return lorem.words(randint(1, num_of_words))
def get_random_link():
return lorem.words(random.randrange(2, 5, 1))
def random(request, word):
print(word)
text = lorem.words(word)
print(text)
return HttpResponse(text)
def test_short_words(self):
self.assertEqual(len(lorem.words(4).split()), 4, "Should be 4")
def create_contract():
"""
Erstellt das Dokument
Im Content übergeben werden "elements",
diese Elements sind die Komponenten aus denen ein Dokument zusammengestellt wird
z.B. Tabellen etc.
Daten die in diesen Tabellen, Textelementen etc. stehen werden nicht hier übergeben sondern in
createComponents()
In "content" übergeben werden Daten statische Daten wie "Ansprechpartner", Firmenadresse etc.
"""
# TODO: Statische Daten anpassen
content = {
'elements': createComponents(),
'company_full_name': lorem.words(1),
'company_addr1': lorem.words(1),
'company_addr2': lorem.words(1),
'name_sig_1': lorem.words(2),
'name_sig_2': lorem.words(2),
'datum': date.today().strftime("%d.%m.%Y"),
'ort': lorem.words(1),
'anspr1': lorem.words(2),
'anspr_pr_1': lorem.words(2),
'rec': lorem.words(2),
'rec_addr1': lorem.words(2),
'rec_addr2': lorem.words(2),
}
file_loader = FileSystemLoader('./')
env = Environment(loader=file_loader)
env.filters['isParagraph'] = HtmlElementType.isParagraph
env.filters['isAddress'] = HtmlElementType.isAddress
env.filters['isGeneric'] = HtmlElementType.isGeneric
env.filters['isSingature'] = HtmlElementType.isSingature
env.filters['isTable'] = HtmlElementType.isTable
env.filters['isHeading'] = HtmlElementType.isHeading
env.filters['isSideparagraph'] = HtmlElementType.isSideparagraph
env.filters['isUserHtml'] = HtmlElementType.isUserHtml
env.filters['isSubject'] = HtmlElementType.isSubject
template = env.get_template('contract.html')
html = template.render(content)
options = {
'--header-html': './header.html',
'--footer-html': './footer.html',
'footer-right': 'Seite [page] von [topage]',
'footer-left': content.get("company_full_name", lorem.words(1)),
'footer-font-size': '6',
'footer-line': '',
'--footer-font-name': 'Open Sans',
'--footer-spacing': '8',
}
pdfkit.from_string(html, 'out.pdf', options=options, css="./contract.css")
def test_placeholder_test_suite():
kwargs = {
"name": lorem.words(1),
"tests": str(np.random),
"failures": lorem.words(1),
"errors": lorem.words(1),
"group": lorem.words(1),
"time": lorem.words(1),
"skipped": lorem.words(1),
"timestamp": lorem.words(1),
"hostname": lorem.words(1),
"id": lorem.words(1),
"package": lorem.words(3).replace(' ', '.'),
"file": lorem.words(1),
"log": lorem.words(1),
"url": lorem.words(1),
"version": lorem.words(1),
'system_err': [],
'system_out': [],
'properties': [],
'testcases': [],
}
for i in range(int(np.random.uniform(0, 10))):
kwargs['system_err'].append(lorem.words(int(np.random.uniform(3, 10))))
for i in range(int(np.random.uniform(0, 10))):
kwargs['system_out'].append(lorem.words(int(np.random.uniform(3, 10))))
for i in range(int(np.random.uniform(0, 10))):
kwargs['properties'].append(
{lorem.words(1): lorem.words(int(np.random.uniform(1, 4)))})
test_suite = TestSuite(**kwargs)
def test_long_words(self):
self.assertEqual(len(lorem.words(600).split()), 600, "Should be 600")
def createComponents():
"""
Hier werden die Komponenten des Dokumentes erstellt
Die Reihenfolge ist wichtig!
:return: Komponenten als Liste
"""
# TODO: Die richtigen Daten einfügen und nutzen
# Liste der Komponenten wird initialisiert
elements = []
# Das Adressfeld wird initialisiert (muss immer am Anfang stehen!)
# Die Daten dafür müssen im content dict angepasst werden
elements.append(HtmlContent(element_type=HtmlElementType.ADDRESSFIELD))
# Ein Betreff wird eingefügt
elements.append(
HtmlContent(title=lorem.words(2),
element_type=HtmlElementType.SUBJECT))
# Generische Textabsätze werden mit Überschrift hinzugefügt
for i in range(0, 5):
title = lorem.words(4)
content = lorem.paragraphs(2)
elements.append(
HtmlContent(title=title,
content=content,
element_type=HtmlElementType.PARAGRAPH))
# Die Zeilen einer Tabelle werden initialisiert
table_content = []
for i in range(0, 10):
title = lorem.words(2)
content = lorem.words(5)
# Die Zeilen werden befüllt
table_content.append(
HtmlContent(title=title,
content=content,
element_type=HtmlElementType.TABLEROW))
# Die Zeilen werden einer Tabelle hinzugefügt und die den Komponenten
elements.append(
HtmlContent(title="Testtabelle",
content=table_content,
element_type=HtmlElementType.TABLE))
# Eine Unter-Überschrift wurd hinzugefügt
elements.append(
HtmlContent(title=lorem.words(2),
element_type=HtmlElementType.HEADING))
# Es werden Absätze mit dem Titel links und dem Inhalt rechts hinzugefügt
for i in range(0, 5):
title = lorem.words(2)
content = lorem.paragraphs(1)
elements.append(
HtmlContent(title=title,
content=content,
element_type=HtmlElementType.SIDEPARAGRAPH))
# Absatz vor den Unterschriften und Unterschriften
elements.append(
HtmlContent(content=lorem.paragraphs(1),
element_type=HtmlElementType.PARAGRAPH))
elements.append(HtmlContent(element_type=HtmlElementType.SIGNATURES))
return elements
def generate_description():
return lt.words(random.randint(50, 80))
def generate_profile_heading():
return lt.words(random.randint(5, 9))
if node.left != None:
Print_tree(node.left)
if node.right != None:
Print_tree(node.right)
samples = 200
increment = 1000
N = 25
N_samples = N-1
linear_times = list()
binary_times = list()
for iteration in range(0, samples + N_samples):
text = lorem.words(iteration * increment)
words = [word.strip('.,!?\n').lower() for word in text.split(" ")]
binary_tree = Generate_binary_tree_from_word_list(words)
word = lorem.words(1)
start_time = time.perf_counter()
Linear_count(word, words)
total_time = (time.perf_counter() - start_time)
linear_times.append(total_time)
start_time = time.perf_counter()
Binary_count(word, binary_tree)
total_time = (time.perf_counter() - start_time)
binary_times.append(total_time)
