class TestPtBr(unittest.TestCase):
def setUp(self):
self.factory = Faker('pt_BR')
def test_address(self):
country = self.factory.country()
assert isinstance(country, string_types)
street = self.factory.street_name()
assert isinstance(street, string_types)
city = self.factory.street_address()
assert isinstance(city, string_types)
neighborhood = self.factory.neighborhood()
assert isinstance(neighborhood, string_types)
state = self.factory.state()
assert isinstance(state, string_types)
state_abbr = self.factory.state_abbr()
assert isinstance(state_abbr, string_types)
address = self.factory.address()
assert isinstance(address, string_types)
class TestZhCN(unittest.TestCase):
""" Tests addresses in the zh_cn locale """
def setUp(self):
self.factory = Faker('zh_CN')
def test_address(self):
country = self.factory.country()
assert isinstance(country, string_types)
street = self.factory.street_name()
assert isinstance(street, string_types)
city = self.factory.street_address()
assert isinstance(city, string_types)
province = self.factory.province()
assert isinstance(province, string_types)
district = self.factory.district()
assert isinstance(district, string_types)
address = self.factory.address()
assert isinstance(address, string_types)
for _ in range(100):
assert re.match(r'\d{5}', self.factory.postcode())
def AddressWrapper(): """ Again, wrapper to it will be easier for me to remember. :return: Address as str """ fake = Faker() return fake.address()
class TestHuHU(unittest.TestCase):
""" Tests addresses in the hu_HU locale """
def setUp(self):
self.factory = Faker('hu_HU')
def test_postcode_first_digit(self):
# Hungarian postcodes begin with 'H-' followed by 4 digits.
# The first digit may not begin with a zero.
for _ in range(100):
pcd = self.factory.postcode()
assert pcd[2] > "0"
def test_street_address(self):
"""
Tests street address.
A street address must consist of a street name, a place type and a number, and end in a period point.
"""
address = self.factory.street_address()
assert address[-1] == '.'
# Check for correct capitalisation of place type
assert address.split(" ")[-2][0].islower()
# Check for street number format
assert re.match(r"\d{1,4}\.", address.split(" ")[-1])
def test_street_address_with_county(self):
"""Tests street address with country. A street address must be:
- in three rows,
- starting with a valid street address,
- contain a valid post code,
- contain the place name validly capitalized.
"""
address = self.factory.street_address_with_county()
# Number of rows
assert len(address.split("\n")) == 3
first, second, last = address.split("\n")
# Test street address
assert first[0].isupper()
assert first.split(" ")[-2][0].islower()
assert re.match(r"\d{1,4}\.", first.split(" ")[-1])
# Test county line
assert second.split(" ")[-1][0].islower()
assert second.split(" ")[0][0].isupper()
# Test postcode
assert re.match(r"H-[1-9]\d{3}", last.split(" ")[0])
# Test place name capitalization
assert last.split(" ")[-1][0].isupper()
def test_address(self):
""" Tests the address provider in the hu_HU locale """
address = self.factory.address()
assert isinstance(address, string_types)
address_with_county = self.factory.street_address_with_county()
assert isinstance(address_with_county, string_types)
def build_test_data(
total_companies=100,
total_departments_per_company=10,
total_employees_per_company=50
):
"""Add a context in which we can run the tests with the test data"""
print('Building test data...')
# Drop the database collections
Company.get_collection().drop()
Employee.get_collection().drop()
# Create a faker object
fake = Faker()
fake.seed(11061979)
random.seed(11061979)
# Build companies
companies = []
for company_index in range(0, total_companies):
company = Company(
name=fake.company(),
departments=[],
address=fake.address(),
tel=fake.phone_number(),
website_url=fake.uri()
)
# Build departments
for department_index in range(0, total_departments_per_company):
department = Department(
name=fake.word(),
year_end=fake.date_time_this_year(False, True),
annual_budget=fake.pyint()
)
company.departments.append(department)
companies.append(company)
Company.insert_many(companies)
# Build employees
for company in companies:
for employee_index in range(0, total_employees_per_company):
employee = Employee(
first_name=fake.first_name(),
last_name=fake.last_name(),
dob=fake.date(),
role=fake.job(),
tel=fake.phone_number(),
email=fake.email(),
annual_salary=fake.pyint(),
ssn=fake.ssn(),
company=company,
department=random.choice(company.departments)
)
employee.insert()
def create(self, username='******'):
"""Add new contact."""
homepage = home.HomePage(self.driver)
homepage.click_menu_link_add_contact()
contactspage1 = contacts.ContactAddPage(self.driver)
#generating random string
somestring = ''.join(random.sample(string.uppercase + string.digits, 10))
contactspage1.enter_address(username)
contactspage1.submit()
# Now user should be located on next page
#contactspage1.submit()
contactspage2 = contacts.ContactEditPage(self.driver)
#print contactspage2.get_value('firstname')
#assert contactspage2.get_value('firstname'),'someAddress_'+somestring
fake = Faker()
#fake.seed(22)
contactspage2.set_value('middlename', fake.last_name())
contactspage2.set_value('lastname', fake.first_name())
contactspage2.set_value('nickname', fake.last_name())
contactspage2.set_value('photo', 'test_files/pictures/001.jpg')
contactspage2.set_value('title', 'title'+somestring)
contactspage2.set_value('company', 'company'+somestring)
contactspage2.set_value('address', fake.address())
contactspage2.set_value('home', fake.phone_number())
contactspage2.set_value('mobile', fake.phone_number())
contactspage2.set_value('work', fake.phone_number())
contactspage2.set_value('fax', fake.phone_number())
contactspage2.clear_value('email')
contactspage2.set_value('email', fake.free_email())
# 'email'+somestring)
contactspage2.set_value('email2', fake.free_email())
contactspage2.set_value('email3', fake.free_email())
contactspage2.set_value('homepage', 'http://localhost/#'+somestring)
contactspage2.set_value('bday', 'bday'+somestring)
contactspage2.set_value('bmonth', 'bmonth'+somestring)
contactspage2.set_value('byear', 'byear'+somestring)
contactspage2.set_value('aday', 'aday'+somestring)
contactspage2.set_value('amonth', 'amonth'+somestring)
contactspage2.set_value('ayear', 'ayear'+somestring)
contactspage2.set_value('new_group', 'new_group'+somestring)
contactspage2.set_value('address2', fake.address())
contactspage2.set_value('phone2', 'phone2'+somestring)
contactspage2.set_value('notes', 'notes'+somestring)
contactspage2.submit()
def gen_data():
faker_obj = Faker()
data = list()
for i in range(10):
column = [
i,
faker_obj.name_female(),
faker_obj.phone_number(),
faker_obj.address()
]
data.append(column)
return data
def generate_fake(count=100, **kwargs):
"""Generate a number of fake reports for testing."""
from sqlalchemy.exc import IntegrityError
from random import seed, choice, randint
from datetime import timedelta
from faker import Faker
import random
import string
def flip_coin():
"""Returns True or False with equal probability"""
return choice([True, False])
def rand_alphanumeric(n):
"""Returns random string of alphanumeric characters of length n"""
r = ''.join(random.choice(string.ascii_uppercase + string.digits)
for _ in range(n))
return r
agencies = Agency.query.all()
users = User.query.all()
fake = Faker()
seed()
for i in range(count):
l = Location(
original_user_text=fake.address(),
latitude=str(fake.geo_coordinate(center=39.951021,
radius=0.01)),
longitude=str(fake.geo_coordinate(center=-75.197243,
radius=0.01))
)
r = IncidentReport(
vehicle_id=rand_alphanumeric(6),
# Either sets license plate to '' or random 6 character string
license_plate=rand_alphanumeric(6)
if flip_coin() else '',
location=l,
date=fake.date_time_between(start_date="-1y", end_date="now"),
duration=timedelta(minutes=randint(1, 30)),
agency=choice(agencies),
user=choice(users),
picture_url=fake.image_url(),
description=fake.paragraph(),
send_email_upon_creation=False,
**kwargs
)
db.session.add(r)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
class TestJaJP(unittest.TestCase):
""" Tests addresses in the ja_JP locale """
def setUp(self):
self.factory = Faker('ja')
def test_address(self):
""" Test"""
country = self.factory.country()
assert isinstance(country, string_types)
assert country in JaProvider.countries
prefecture = self.factory.prefecture()
assert isinstance(prefecture, string_types)
assert prefecture in JaProvider.prefectures
city = self.factory.city()
assert isinstance(city, string_types)
assert city in JaProvider.cities
town = self.factory.town()
assert isinstance(town, string_types)
assert town in JaProvider.towns
chome = self.factory.chome()
assert isinstance(chome, string_types)
assert re.match(r"\d{1,2}丁目", chome)
ban = self.factory.ban()
assert isinstance(ban, string_types)
assert re.match(r"\d{1,2}番", ban)
gou = self.factory.gou()
assert isinstance(gou, string_types)
assert re.match(r"\d{1,2}号", gou)
building_name = self.factory.building_name()
assert isinstance(building_name, string_types)
assert building_name in JaProvider.building_names
postcode = self.factory.postcode()
assert isinstance(postcode, string_types)
assert re.match(r"\d{3}-\d{4}", postcode)
zipcode = self.factory.zipcode()
assert isinstance(zipcode, string_types)
assert re.match(r"\d{3}-\d{4}", zipcode)
address = self.factory.address()
assert isinstance(address, string_types)
class FakerGenerator(object):
"""Generate different data by this class."""
fake = None
def __init__(self, language=None):
if language:
self.fake = Factory.create(language)
else:
self.fake = Faker()
def gen_user_info(self):
user = User()
user.name = self.fake.name()
user.address = self.fake.address()
return user
def get_full_values(self):
full_values = FullValues()
full_values.address = self.fake.address()
# full_values.barcode = self.fake.barcode()
full_values.color = self.fake.safe_hex_color()
full_values.company = self.fake.company()
full_values.credit_card = self.fake.credit_card_number()
full_values.currency = self.fake.currency_code()
full_values.date_time = self.fake.date_time()
full_values.file = self.fake.file_name()
full_values.internet = self.fake.company_email()
full_values.job = self.fake.job()
full_values.lorem = self.fake.text(max_nb_chars=200)
full_values.misc = self.fake.password()
full_values.person = self.fake.name_female()
full_values.phone_number = self.fake.phone_number()
full_values.profile = self.fake.profile()
# full_values.python = self.fake.python()
full_values.ssn = self.fake.ssn()
full_values.user_agent = self.fake.user_agent()
return full_values
def people():
fake = Faker()
data = []
for i in range(15):
name = fake.name()
age = fake.random_int(min=18, max=99)
address = fake.address().replace('\n',' ')
salary = fake.random_int(min=50000, max=250000)
data.append((name, age, address, salary))
return data
def seed():
from app.users.models import User, Address
from faker import Faker
fake = Faker()
users = [User(username=fake.user_name(), name=fake.name(),
email=fake.email(), password='******') for i in range(20)]
db.session.add_all(users)
db.session.commit()
addresses = []
for user in users:
address = Address()
address.user = user
address.address = fake.address()
addresses.append(address)
db.session.add_all(addresses)
db.session.commit()
class TestZhTW(unittest.TestCase):
""" Tests addresses in the zh_tw locale """
def setUp(self):
self.factory = Faker('zh_TW')
def test_address(self):
country = self.factory.country()
assert isinstance(country, string_types)
street = self.factory.street_name()
assert isinstance(street, string_types)
city = self.factory.city()
assert isinstance(city, string_types)
address = self.factory.address()
assert isinstance(address, string_types)
def fake():
bmnum = 100
pfnum = 10
tags = ['terrible', 'great', 'smelly', 'sad', 'bright', 'too bright', 'gnarly',\
'awesome', 'happy', 'tremendous']
faker = Faker()
for item in tags:
Tag.objects.create(name=item)
tags = list(Tag.objects.all())
for _ in range(bmnum):
bm = Bookmark.objects.create(title=faker.name(), description=faker.address(), \
_url=faker.url())
for _ in range(3):
bm.tag_set.add(random.choice(tags))
bms = list(Bookmark.objects.all())
hashid = Hashids(salt='Moddey Dhoo')
for idx in range(pfnum):
bm = [bms.pop(random.randint(0, bmnum - idx*10 - idx2 - 1)) for idx2 in range(10)]
pf = Profile.objects.create(username=faker.name(), description=faker.text())
for item in bm:
item.profile = pf
item.save()
item.short = hashid.encode(item.id, pf.id)
item.timestamp = datetime.datetime.utcnow() + datetime.timedelta(weeks=-52)
item.timestamp = item.timestamp.replace(tzinfo=datetime.timezone(offset=datetime.timedelta()))
item.save()
pfs = list(Profile.objects.all())
bms = list(Bookmark.objects.all())
for item in bms:
num = random.randint(1,10)
for idx in range(num):
pf = random.choice(pfs)
timestamp = faker.date_time_this_year().replace(tzinfo=datetime.timezone(offset=datetime.timedelta()))
item.click_set.create(profile=pf, timestamp=timestamp)
item.save()
class TestEnIE(unittest.TestCase):
""" Tests in addresses in the de_DE locale """
def setUp(self):
self.factory = Faker('en_IE')
def test_address(self):
country = self.factory.country()
assert isinstance(country, string_types)
street = self.factory.street_name()
assert isinstance(street, string_types)
city = self.factory.street_address()
assert isinstance(city, string_types)
county = self.factory.county()
assert isinstance(county, string_types)
address = self.factory.address()
assert isinstance(address, string_types)
class TestNoNO(unittest.TestCase):
""" Tests the street address in no_NO locale """
def setUp(self):
self.factory = Faker('no_NO')
def test_postcode(self):
for _ in range(100):
self.assertTrue(re.match(r'^[0-9]{4}$', self.factory.postcode()))
def test_city_suffix(self):
suffix = self.factory.city_suffix()
assert isinstance(suffix, string_types)
def test_street_suffix(self):
suffix = self.factory.street_suffix()
assert isinstance(suffix, string_types)
def test_address(self):
address = self.factory.address()
assert isinstance(address, string_types)
async def hi(event):
if event.fwd_from:
return
if event.is_group and not await is_admin(event, event.message.sender_id):
await event.reply("`You Should Be Admin To Do This!`")
return
fake = Faker()
print("FAKE DETAILS GENERATED\n")
name = str(fake.name())
fake.add_provider(internet)
address = str(fake.address())
ip = fake.ipv4_private()
cc = fake.credit_card_full()
email = fake.ascii_free_email()
job = fake.job()
android = fake.android_platform_token()
pc = fake.chrome()
await event.reply(
f"<b><u> Fake Information Generated</b></u>\n<b>Name :-</b><code>{name}</code>\n\n<b>Address:-</b><code>{address}</code>\n\n<b>IP ADDRESS:-</b><code>{ip}</code>\n\n<b>credit card:-</b><code>{cc}</code>\n\n<b>Email Id:-</b><code>{email}</code>\n\n<b>Job:-</b><code>{job}</code>\n\n<b>android user agent:-</b><code>{android}</code>\n\n<b>Pc user agent:-</b><code>{pc}</code>",
parse_mode="HTML",
)
def test_db():
db.create_all()
db.session.commit()
fake = Faker()
name = fake.name()
address = fake.address()
text = fake.text()
print("name := " + name)
print("address:= " + address)
print("text:= " + text)
u = User(name, address, text)
db.session.add(u)
db.session.commit()
value = db.session.query(User).all()
#user= q.all()
return render_template("user.html", value=value)
def get_user_login(count):
faker = Faker(locale='zh_CN')
data_list = []
for i in range(1, count + 1):
dic = {}
username = faker.name()
password = faker.password(special_chars=False)
gender = random.randint(0, 1)
mobile = faker.phone_num()
email = faker.email()
address = faker.address()
id_card = faker.ssn()
dic['username'] = username
dic['password'] = password
dic['gender'] = gender
dic['mobile'] = mobile
dic['email'] = email
dic['address'] = address
dic['id_card'] = id_card
data_list.append(dic)
return data_list
def gen_fake_data():
fake = Faker("zh_CN")
fake_name = fake.name()
fake_province = fake.province()
fake_city = fake.city()
fake_company = fake_province + fake.company()
fake_company_email = fake.company_email()
fake_bankcard_no = '62' + fake.credit_card_number()
fake_phone_no = fake.phone_number()
fake_ssn_no = fake.ssn()
fake_address = fake.address()
print("BBB Fake姓名:", fake_name)
print("BBB Fake省份:", fake_province)
print("BBB Fake城市:", fake_city)
print("BBB Fake公司名称:", fake_company)
print("BBB Fake公司邮箱:", fake_company_email)
print("BBB Fake银行卡号:", fake_bankcard_no)
print("BBB Fake手机号:", fake_phone_no)
print("BBB Fake身份证:", fake_ssn_no)
print("BBB Fake地址:", fake_address)
class TestNoNO(unittest.TestCase):
""" Tests the street address in no_NO locale """
def setUp(self):
self.factory = Faker('no_NO')
def test_postcode(self):
for _ in range(100):
assert re.match(r'^[0-9]{4}$', self.factory.postcode())
def test_city_suffix(self):
suffix = self.factory.city_suffix()
assert isinstance(suffix, string_types)
def test_street_suffix(self):
suffix = self.factory.street_suffix()
assert isinstance(suffix, string_types)
def test_address(self):
address = self.factory.address()
assert isinstance(address, string_types)
def create_fake_enquiry_csv_row():
fake = Faker()
return {
"enquirer_first_name": fake.name(),
"enquirer_last_name": fake.name(),
"enquirer_job_title": fake.job(),
"enquirer_email": fake.email(),
"enquirer_phone_country_code": random.randint(1, 100),
"enquirer_phone": fake.phone_number(),
"enquirer_request_for_call": get_random_item(ref_data.RequestForCall),
"country": get_random_item(ref_data.Country),
"company_name": fake.company(),
"ist_sector": get_random_item(ref_data.ISTSector),
"company_hq_address": fake.address(),
"website": fake.url(),
"investment_readiness": get_random_item(ref_data.InvestmentReadiness),
"enquiry_stage": get_random_item(ref_data.EnquiryStage),
"enquiry_text": fake.sentence(),
"notes": fake.sentence(nb_words=20),
"date_received": fake.date(),
}
class TestNoNO(unittest.TestCase):
""" Tests the street address in no_NO locale """
def setUp(self):
self.fake = Faker('no_NO')
Faker.seed(0)
def test_postcode(self):
for _ in range(100):
assert re.match(r'^[0-9]{4}$', self.fake.postcode())
def test_city_suffix(self):
suffix = self.fake.city_suffix()
assert isinstance(suffix, str)
def test_street_suffix(self):
suffix = self.fake.street_suffix()
assert isinstance(suffix, str)
def test_address(self):
address = self.fake.address()
assert isinstance(address, str)
def handle(self, *args, **options):
faker = Faker()
self.stdout.write('Start generating and inserting Students')
for _ in range(options['am']):
subject, is_created = Subject.objects.get_or_create(title='Python')
self.stdout.write('Start inserting Students')
student = Student()
student.name = faker.first_name()
student.surname = faker.last_name()
student.age = randint(20, 40)
student.sex = faker.simple_profile()['sex']
student.address = faker.address()
student.description = faker.text()
student.birthday = faker.date_of_birth()
student.email = faker.email()
student.subject = subject
student.save()
self.stdout.write('End inserting Students')
def generate_mock_file(filename, lines, func_list):
fake = Faker()
data = []
obj = {'filename': filename, 'lines': lines}
for _ in range(0, lines):
data.append([
str(randint(1, 10)),
fake.name(),
fake.address().replace("\n", " - "),
str(fake.latitude()),
str(fake.longitude())
])
for key, func in func_list.items():
obj.setdefault(key, len([i for i in filter(func, data)]))
with open(filename, 'w') as randomfile:
for line in data:
randomfile.write('%s\n' % ','.join(line))
return type('MockFile', (object, ), obj)
def seed():
from app.users.models import User, Address
from faker import Faker
fake = Faker()
users = [
User(username=fake.user_name(),
name=fake.name(),
email=fake.email(),
password='******') for i in range(20)
]
db.session.add_all(users)
db.session.commit()
addresses = []
for user in users:
address = Address()
address.user = user
address.address = fake.address()
addresses.append(address)
db.session.add_all(addresses)
db.session.commit()
def dummy_data():
from faker import Faker
from itertools import zip_longest, cycle
fake = Faker()
companies = [
Company(name=fake.company(),
website=fake.url(),
address=fake.address(),
phone=fake.phone_number()) for _ in range(10000)
]
people = [
Person(name=fake.name(), email=fake.email(), phone=fake.phone_number())
for _ in range(20000)
]
users = [User(name=fake.name(), email=fake.email()) for _ in range(100)]
db = Session()
db.add_all(companies)
db.add_all(people)
db.add_all(users)
manager_and_users = zip_longest(*[iter(users)] * 10)
for manager, *rest in manager_and_users:
for user in rest:
user.manager = manager
contact_people = zip_longest(*[iter(people)] * 2)
cycle_users = cycle(users)
for company in companies:
contacts = list(next(contact_people))
company.ceo = contacts[0]
company.primary_contact = contacts[1]
company.sold_by = next(cycle_users)
db.commit()
class ClientGenerator(DataGenerator):
"""
idea is that this will get generated first then we will use it to make transactions
populates a fake client list with
name
address
email
user_name
phone_number
uuid as a client_id
for a given locale
"""
def __init__(self, locale: str='en_AU'):
self.fake_gen = Faker()
def emit(self, tuples_to_emit: int = 10000) -> list:
# emits a list of dicts
client_list = []
for i in range(tuples_to_emit):
client_id = self.fake_gen.uuid4()
name = self.fake_gen.name()
address = self.fake_gen.address()
email = self.fake_gen.email()
username = self.fake_gen.user_name()
phone = self.fake_gen.phone_number()
client_list.append({'client_id': client_id, 'name': name, 'address': address,
'email': email, 'username': username, 'phone': phone})
return client_list
class Fakers(object):
def __init__(self):
super().__init__()
self.faker = Faker('zh_CN')
@property
def mobile_number(self):
return self.faker.phone_number() # 手机号
@property
def ID_card(self):
return self.faker.ssn(min_age=1, max_age=90) # 身份证
@property
def image(self):
return self.faker.image_url() # 图片网址
@property
def word(self):
return self.faker.word() # 随机单词
@property
def license_plate(self):
return self.faker.license_plate() # 车牌号
@property
def address(self):
return self.faker.address() # 随机地址
@property
def randomdate(self):
return self.faker.date(pattern="%Y-%m-%d") # 随机日期（可自定义格式）
@property
def randomtime(self):
return self.faker.time(pattern="%H:%M") # 随机时间（可自定义格式）
@property
def name(self):
return self.faker.name() # 生成名字
def handle(self, *args, **options):
"""This function initializes Faker and
generates information for the each field
in the model "Student"."""
faker = Faker()
subjects_name = ["Python", "Java", "Math", "History"]
for _ in range(options['len']):
self.stdout.write('Start inserting Students')
book = Book()
book.title = uuid.uuid4()
book.save()
subject, _ = Subject.objects.get_or_create(title=random.choice(subjects_name))
subject.save()
student = Student()
student.name = faker.first_name()
student.surname = faker.last_name()
student.age = faker.random_int(min=18, max=80)
student.address = faker.address()
student.description = faker.text()
student.birthday = faker.date_of_birth()
student.email = faker.email()
student.social_url = "https://www.instagram.com/" + student.name + student.surname
student.save()
student.book = book
student.subject = subject
student.save()
teacher, _ = Teacher.objects.get_or_create(name=faker.name())
teacher.students.add (student)
teacher.save()
self.stdout.write('End inserting Students')
def market(self, **kwargs):
fake = Faker('ko_KR')
attributes = {
'studio_name': fake.company(),
'posts': "",
'working_time': {
'start_time': fake.time(pattern="%H:%M:%S", end_datetime=None),
'end_time': fake.time(pattern="%H:%M:%S", end_datetime=None),
},
'costs': fake.pyint(),
'kakao_id': fake.user_name(),
'photographer_idx': fake.pyint(),
'contract_idxs': [], # array of contract idx(int)
'tags': [],
'location': fake.address(),
'phone': fake.phone_number(),
}
for key, value in kwargs.items():
if not key in attributes:
raise ValueError(f'Key error! There is no {key} in Makret')
attributes[key] = value
return attributes
def create_customers():
print('Starting create_customers() ...')
import pandas as pd
import datetime
from faker import Faker
import numpy as np
# Load data
df_data_1 = pd.read_csv(ONLINE_RETAIL_CSV, header=None, usecols=[6])
# Get unique customer IDs
df_data_1 = df_data_1[6].unique()
# initiate faker
fake = Faker('en_GB')
# create lists of names and addresses
names = [fake.name() for i in range(0, len(df_data_1))]
addresses = [
fake.address().replace("\n", " ") for i in range(0, len(df_data_1))
]
# build df
df = pd.DataFrame({
'CustomerID': df_data_1,
'Name': names,
'Address': addresses
})
df['validFrom'] = datetime.datetime.now()
# df['validTo'] = np.NaN
# Sort dataframe
df.sort_values(by=['CustomerID'], inplace=True)
# finally save
df.to_csv(ONLINE_RETAIL_CUSTOMERS,
index=False,
encoding='utf-8',
header=False)
print('Finished create_customers() ...')
def _gen_file(cls,
header: bool = True,
sep: str = '|',
type: str = None,
name: str = None):
ftype = type or FileInspectorCsvTest.testfile['type']
fname = name or FileInspectorCsvTest.testfile['name']
gen = FileGenerator(type=ftype,
name=fname,
header=header,
seperator=sep)
faker = Faker()
for n in range(100):
gen.add_rows({
'Lat': faker.coordinate(center=74.0, radius=0.10),
'Lon': faker.coordinate(center=40.8, radius=0.10),
'Txt': faker.sentence(),
'Nam': faker.name(),
'Add': faker.address().replace("\n", '\\n'),
'Job': faker.job()
})
return gen
class GeneratorSwitch:
def __init__(self):
self.fake = Faker()
self.column = None
def fake_name(self):
return self.fake.name()
def fake_job(self):
return self.fake.job()
def fake_email(self):
return self.fake.email()
def fake_domain(self):
return self.fake.domain_name()
def fake_phone(self):
return self.fake.phone_number()
def fake_company(self):
return self.fake.company()
def fake_text(self):
return ' '.join(self.fake.sentences(self.fake.random_int(self.column.start, self.column.end)))
def fake_int(self):
return str(self.fake.random_int(self.column.start, self.column.end))
def fake_address(self):
return self.fake.address()
def fake_date(self):
return self.fake.date()
def dispatch(self, column):
method_name = 'fake_' + str(column.kind)
self.column = column
return getattr(self, method_name)()
def generateFakeUserData(connection, tables):
fk = Faker(locale=LOCALE)
# Oracle is different from MySQL, it has no auto_increment attribute for
# an INTEGER field. you have create a sequence first, and call sequence.nextval
#
try:
connection.execute(
text("""
CREATE SEQUENCE user_id_seq INCREMENT BY 1 NOCYCLE
"""))
except DatabaseError:
# When run this program again , Oracle already has the `user_id_seq`
# sequence, so it throw the ORA-xxxxx error.
print("[WARNING]: `user_id_seq` sequence has been created.")
while True:
username = fk.name()
address = fk.address()
phone = fk.phone_number()
email = fk.email()
print("=" * 50)
print("Generate username:%s\n address:%s\n phone:%s\n email:%s\n\n" % (
username,
address,
phone,
email,
))
stmt = tables["my_user"].insert().values(username=username,
address=address,
phone=phone,
email=email)
connection.execute(stmt)
print(stmt)
yield (
username,
address,
phone,
email,
)
def init_needed(apps, schema_editor):
fake = Faker('ru_RU')
ContainerType = apps.get_model('boxes', 'ContainerType')
NeededContainer = apps.get_model('boxes', 'NeededContainer')
User = apps.get_model('core', 'User')
Station = apps.get_model('geo', 'Station')
containers = []
users = User.objects.all()[User.objects.count() / 2:]
start_date = datetime.now() + timedelta(days=random.randint(2, 20))
while len(containers) < random.randint(20, 60):
containers.append(
NeededContainer(
type=ContainerType.objects.order_by('?').first(),
location=Station.objects.order_by('?').first(),
address=fake.address(),
count=random.randint(2, 20),
date_from=start_date,
date_till=start_date + timedelta(days=random.randint(2, 20)),
owner=users[random.randint(0,
len(users) - 1)],
))
NeededContainer.objects.bulk_create(containers)
def generate_fake_student(request):
fake = Faker()
full_name = fake.name()
first_name, last_name = full_name.split(' ')
age = random.randint(10, 100)
n_schools = School.objects.count()
index = random.randint(0, n_schools - 1)
school = School.objects.all()[index]
address = fake.address()
fake_student = Student(first_name=first_name,
last_name=last_name,
age=age,
school=school,
address=address)
fake_student.save()
return HttpResponse("studetns named %s is generated in database." %
full_name)
def handle(self, *args, **options):
"""
In a loop, prints the specified
number of students in func "add_arguments"
"""
faker = Faker()
for new_student in range(options['len']):
subject, _ = Subject.objects.get_or_create(title='Python') # noqa
subject.save()
student_marks = ReportCard()
student_marks.report_card = uuid.uuid4()
student_marks.save()
student = Student()
student.name = faker.first_name()
student.surname = faker.last_name()
student.age = faker.random_int(min=18, max=50)
# student.sex = faker.simple_profile()['sex']
student.address = faker.address()
student.description = faker.text()
student.birthday = faker.date_between()
student.email = faker.email()
student.social_url = f'http://{faker.domain_name()}'
student.is_active = faker.boolean(chance_of_getting_true=100)
student.subject = subject
# student.teacher = teacher
student.report_card = student_marks
student.save()
teacher, _ = Teacher.objects.get_or_create(
name_surname=faker.random_element(
elements=('Michael Jackson', 'Jason Bourne',
'Freddy Krueger'))) # noqa E501 line too long
student.teacher.add(teacher)
teacher.save()
def get_thousand_list_rows():
fake = Faker()
append_list = list()
st = time.process_time()
for counter in range(10000):
data = list()
data.append(fake.name())
data.append(substitute('[^0-9\-\(\)]', '', fake.phone_number()))
data.append(fake.email())
data.append(fake.sentence())
data.append(fake.date())
data.append('M' if counter % 3 == 0 else 'F' if counter %
2 == 0 else 'O')
data.append(substitute('\\n', ' ', fake.address()))
data.append(float(fake.latitude()))
data.append(float(fake.longitude()))
data.append(fake.image_url())
data.append(fake.uri())
append_list.append(data)
ed = time.process_time()
print('\nGenerated 10,000 Fake Data in ', ed - st, ' sec.\n')
return append_list
def generate_test_data(region, number, file_path, csv_file_delimiter="|"):
"""
Author : Niket Shinde
:param region:
:param x:
:param file_path:
:param csv_file_delimiter:
:return:
"""
print(region)
fake = Faker(str(region))
cust_data = {}
for i in range(0, int(number)):
cust_data[i] = {}
cust_data[i]['id'] = random.randrange(999, 10000)
cust_data[i]['first_name'] = fake.first_name()
cust_data[i]['last_name'] = fake.last_name()
cust_data[i]['name'] = cust_data[i]['first_name'] + ' ' + cust_data[i][
'last_name']
cust_data[i]['ssn'] = fake.ssn()
cust_data[i]['dob'] = fake.date_of_birth(
tzinfo=None, minimum_age=10, maximum_age=115).strftime("%x")
cust_data[i]['email'] = fake.email()
cust_data[i]['phone'] = fake.phone_number()
cust_data[i]['street_name'] = fake.street_name()
cust_data[i]['street_number'] = random.randrange(1, 99)
cust_data[i]['flat_number'] = random.randrange(1, 999)
cust_data[i]['floor_number'] = random.randrange(1, 20)
cust_data[i]['postcode'] = fake.postcode()
cust_data[i]['city'] = fake.city_name()
cust_data[i]['address'] = fake.address()
cust_data[i]['comment'] = fake.text()
cust_data[i]['latitude'] = str(fake.latitude())
cust_data[i]['longitude'] = str(fake.longitude())
logger.debug(cust_data)
df = pd.DataFrame.from_dict(cust_data, orient='index')
df.to_csv(path_or_buf=file_path + '.csv', sep=csv_file_delimiter)
return cust_data
class TestPtBr(unittest.TestCase):
def setUp(self):
self.fake = Faker('pt_BR')
Faker.seed(0)
def test_address(self):
country = self.fake.country()
assert isinstance(country, str)
street = self.fake.street_name()
assert isinstance(street, str)
city = self.fake.street_address()
assert isinstance(city, str)
neighborhood = self.fake.neighborhood()
assert isinstance(neighborhood, str)
state = self.fake.state()
assert isinstance(state, str)
state_abbr = self.fake.state_abbr()
assert isinstance(state_abbr, str)
address = self.fake.address()
assert isinstance(address, str)
def test_raw_postcode(self):
for _ in range(100):
postcode = self.fake.postcode(formatted=False)
assert isinstance(postcode, str)
assert re.match(r'^\d{8}$', postcode)
def test_formatted_postcode(self):
for _ in range(100):
postcode = self.fake.postcode()
assert isinstance(postcode, str)
assert re.match(r'^\d{5}-?\d{3}$', postcode)
class LoadTables:
def __init__(self, engine):
session = sessionmaker(bind=engine)
self.db_session = session()
self.fake = Faker()
def load_customers(self):
customer_dict_list = list()
for i in range(1, 101):
customer_dict = dict()
customer_dict["customer_id"] = i
customer_dict["customer_name"] = self.fake.name()
customer_dict_list.append(customer_dict)
self.load_records(Customer, customer_dict_list)
def load_addresses(self):
address_dict_list = list()
for i in range(1, 101):
address_dict = dict()
address_dict["address_id"] = i
address_dict["address"] = self.fake.address()
address_dict["customer_id"] = random.randint(1, 100)
address_dict_list.append(address_dict)
self.load_records(Address, address_dict_list)
def load_suppliers(self):
with open('suppliers.json') as json_file:
supplier_dict_list = json.load(json_file)
self.load_records(Supplier, supplier_dict_list)
def load_records(self, table, records):
try:
self.db_session.bulk_insert_mappings(table, records)
self.db_session.commit()
except Exception as e:
print(sys.exc_info())
finally:
self.db_session.close()
def build_fake_profile(self):
locale_temp = self.locale
# locale_str = locale_temp.encode("utf-8")
# locale.setlocale(locale.LC_ALL, locale_str)
# sym = locale.localeconv()['int_curr_symbol']
# currency_name = numbers.get_currency_name(sym, locale=locale_str)
# reverting the original locale to en_US
original_locale = 'en_US'
# locale.setlocale(locale.LC_ALL, original_locale)
try:
fake = Faker(self.locale)
address = fake.address()
except:
fake = Faker('en_US')
address = ''
credit_card_number = fake.credit_card_number()
credit_card_expire = fake.credit_card_expire()
credit_card_provider = fake.credit_card_provider()
first_name = fake.first_name()
last_name = fake.last_name()
random_base64 = binascii.b2a_hex(os.urandom(5))
e_mail = '{}_{}'.format(random_base64, fake.email())
profile_list = {
"phone_number": self.fake_number,
"phone_number_no_prefix": self.fake_number_no_prefix,
"credit_card": {
"credit_card_number": credit_card_number,
"credit_card_expire": credit_card_expire,
"credit_card_provider": credit_card_provider
},
# "currency": currency_name,
"first_name": first_name,
"last_name": last_name,
"address": address,
"e_mail": e_mail
}
return profile_list
def generate_fake_new_user(is_staff=False):
fake = Faker()
name = fake.name()
email = fake.email()
phone = get_phone()
# Ensuring we don't have an accidental collision in the db.
# Super rare probabilistically, but still.
while Member.objects.filter(phone=phone).count() != 0:
phone = get_phone()
while Member.objects.filter(name=name).count() != 0:
name = fake.name()
user_account = User.objects.create_user(name,
email,
"fake_password",
is_staff=is_staff)
member = Member.objects.create(
user=user_account,
name=name,
first_name=fake.first_name(),
last_name=fake.last_name(),
legal_name=name,
address=fake.address(),
email=email,
phone=get_phone(),
rollnumber=Member.objects.count() + 1,
member_score=random.randint(0, 100),
inactive_flag=False,
abroad_flag=False,
present=random.randint(0, 50),
position="Test Member",
)
return member
class SalesRepDataGenerator(DataGenerator):
fake = None
reps_left = rep_count
def __init__(self):
self.fake = Faker()
def gen_row(self):
row = {}
row['id'] = self.reps_left
self.reps_left -= 1
if self.reps_left == -1:
return None
row['name'] = self.fake.name()
row['address'] = self.fake.address().replace('\n', ', ')
row['salary'] = random.randrange(5, 11) * 10000
row['quota'] = random.randrange(5, 11) * 100000
row['start_date'] = str(
self.fake.date_this_decade(before_today=True, after_today=False))
return row
def create_fake_search_data(records=100, seed=None):
fake = Faker()
if seed:
fake.seed(seed)
resources = []
for x in range(0, records):
resources.append(
mommy.make(Resource,
title = fake.sentence(nb_words=5, variable_nb_words=True),
description = fake.text(max_nb_chars=200),
uri = fake.url(),
)
)
for resource in resources:
curation = mommy.make(Curation, resource = resource)
for x in range(0, 2):
curation.tags.add(fake.word())
for x in range(0, 5):
mommy.make(Location,
resource = resource,
formatted_address = fake.address(),
latitude = fake_latitude(),
longitude = fake_longitude(),
)
resource.tags.add(fake.word())
resource.save()
return resources
from faker import Faker
import csv
fake = Faker()
with open('large.csv','w') as f1:
writer=csv.writer(f1, delimiter=',',lineterminator='\n',)
writer.writerow([''] + range(100))
for i in range(100):
row = [i] + [10] + [fake.name()] +[fake.address()]
writer.writerow(row)
class Anonymizer(object):
def __init__(self, logger):
self.us_faker = Faker()
self.faker = Faker('fr_FR')
self.logger = logger
self.session = DBSESSION()
def _zipcode(self):
if hasattr(self.faker, 'zipcode'):
return self.faker.zipcode()
else:
return self.faker.postcode()
def _an_activity(self):
from autonomie.models.activity import Activity, ActivityType
from autonomie.models.workshop import Workshop
for activity in self.session.query(Activity):
for fieldname in (
'point',
'objectifs',
'action',
'documents',
'notes'
):
setattr(activity, fieldname, self.faker.text())
for workshop in self.session.query(Workshop).options(load_only('id')):
workshop.description = self.faker.text()
self.session.merge(workshop)
type_labels = (
u"RV conseil",
u"RV suivi",
u"RV Gestion",
u"RV Admin",
u"RV RH",
u"RV Compta",
u"RV hebdo",
u"RV Mensuel",
)
for index, typ in enumerate(self.session.query(ActivityType).all()):
typ.label = type_labels[index % 7]
def _an_commercial(self):
from autonomie.models.commercial import TurnoverProjection
for t in self.session.query(TurnoverProjection):
t.comment = self.faker.text()
def _an_company(self):
from autonomie.models.company import Company
for comp in self.session.query(Company):
comp.name = self.faker.company()
comp.goal = self.faker.bs()
comp.comments = self.faker.catch_phrase()
comp.phone = self.faker.phone_number()
comp.mobile = self.faker.phone_number()
comp.email = self.faker.ascii_safe_email()
header = build_header(
u"{0}\n {1} - {2}".format(comp.name, comp.phone, comp.email)
)
comp.header = {'name': 'header.png', 'data': header}
self.session.execute(u"update company set cgv=''")
def _an_competence(self):
from autonomie.models.competence import (
CompetenceGridItem,
CompetenceGridSubItem,
)
for item in self.session.query(CompetenceGridItem):
item.progress = self.faker.text()
for item in self.session.query(CompetenceGridSubItem):
item.comments = self.faker.text()
def _an_config(self):
from autonomie.models.config import Config, ConfigFiles
Config.set('cae_admin_mail', self.faker.ascii_safe_email())
Config.set('welcome', self.faker.sentence(nb_words=15))
ConfigFiles.set(
'logo.png',
{
'data': pkg_resources.resource_stream(
'autonomie',
'static/img/autonomie.jpg'
),
'filename': 'logo.jpg',
}
)
Config.set('coop_cgv', self.faker.paragraph(nb_sentences=40))
Config.set('coop_pdffootertitle', u"""Une activité de ma CAE SARL SCOP à \
capital variable""")
Config.set('coop_pdffootercourse', u"""Organisme de formation N° de déclaration \
d'activité au titre de la FPC : xx xx xxxxx. MA CAE est exonérée de TVA pour \
les activités s'inscrivant dans le cadre de la formation professionnelle \
conformément à l'art. L920-4 du Code du travail et de l'art. 202 C de \
l'annexe II du code général des impôts""")
footer = u"""RCS XXXX 000 000 000 00000 - SIRET 000 \
000 000 000 00 - Code naf 0000Z TVA INTRACOM : FR0000000. Siège social : 10 \
rue vieille 23200 Aubusson"""
Config.set('coop_pdffootercontent', footer)
Config.set('coop_pdffootertext', footer)
Config.set('coop_invoicepayment', u"""Par chèque libellé à l'ordre de : \
MA CAE/ %ENTREPRENEUR%
à envoyer à l'adresse suivante :
MA CAE/ %ENTREPRENEUR%
10 rue Vieille
23200 Aubusson
Ou par virement sur le compte de MA CAE/ %ENTREPRENEUR%
MA BANQUE
RIB : xxxxx xxxx xxxxxxxxxxxxx
IBAN : xxxx xxxx xxxx xxxx xxxx xxxx xxx
BIC : MABAFRMACAXX
Merci d'indiquer le numéro de facture sur le libellé de votre virement ou \
dos de votre chèque.
""")
Config.set("coop_invoicelate", u"""Tout retard de paiement entraînera à titre de \
clause pénale, conformément à la loi 92.1442 du 31 décembre 1992, une \
pénalité égale à un taux d'intérêt équivalent à une fois et demi le taux \
d'intérêt légal en vigueur à cette échéance.
Une indemnité de 40 euros forfaitaire sera demandée en sus pour chaque \
facture payée après l’échéance fixée. Celle-ci n’est pas soumise à TVA.""")
Config.set("activity_footer", footer)
Config.set('workshop_footer', footer)
def _an_customer(self):
from autonomie.models.customer import Customer
for cust in self.session.query(Customer):
cust.name = self.faker.company()
cust.address = self.faker.street_address()
cust.zipcode = self._zipcode()
cust.city = self.faker.city()
cust.lastname = self.faker.last_name()
cust.firstname = self.faker.first_name()
cust.email = self.faker.ascii_safe_email()
cust.phone = self.faker.phone_number()
cust.fax = self.faker.phone_number()
cust.tva_intracomm = ""
cust.comments = self.faker.bs()
def _an_expense(self):
from autonomie.models.expense.sheet import (
BaseExpenseLine,
ExpenseKmLine,
Communication,
)
for line in self.session.query(BaseExpenseLine):
line.description = self.faker.text()
for line in self.session.query(ExpenseKmLine):
line.start = self.faker.city()
line.end = self.faker.city()
for com in self.session.query(Communication):
com.content = self.faker.text()
def _an_node(self):
from autonomie.models.node import Node
for node in self.session.query(Node):
node.name = self.faker.sentence(nb_words=4, variable_nb_words=True)
def _an_payment(self):
from autonomie.models.payments import BankAccount
for b in self.session.query(BankAccount):
b.label = u"Banque : {0}".format(self.faker.company())
def _an_project(self):
from autonomie.models.project import Project, Phase
for p in self.session.query(Project):
p.name = self.faker.sentence(nb_words=5)
p.definition = self.faker.text()
for p in self.session.query(Phase):
if not p.name.is_default():
p.name = self.faker.sentence(nb_words=3)
def _an_sale_product(self):
from autonomie.models.sale_product import (
SaleProductCategory,
SaleProduct,
SaleProductGroup,
)
for cat in self.session.query(SaleProductCategory):
cat.title = self.faker.sentence(nb_words=3)
cat.description = self.faker.text()
for prod in self.session.query(SaleProduct):
prod.label = self.faker.sentence(nb_words=2)
prod.description = self.faker.text()
for group in self.session.query(SaleProductGroup):
group.title = self.faker.sentence(nb_words=2)
group.description = self.faker.text()
def _an_statistic(self):
from autonomie.models.statistics import (
StatisticSheet
)
for s in self.session.query(StatisticSheet):
s.title = self.faker.sentence(nb_words=4)
def _an_task(self):
from autonomie.models.task import (
Task,
DiscountLine,
TaskLine,
TaskLineGroup,
Estimation,
TaskStatus,
)
for task in self.session.query(Task):
if task.status_comment:
task.status_comment = self.faker.text()
task.description = self.faker.text()
task.address = task.customer.full_address
task.workplace = self.faker.address()
task.payment_conditions = u"Par chèque ou virement à réception de "
u"facture"
if task.notes:
task.notes = self.faker.text()
for line in self.session.query(DiscountLine):
line.description = self.faker.text()
for line in self.session.query(TaskLine):
line.description = self.faker.text()
for group in self.session.query(TaskLineGroup):
if group.title:
group.title = self.faker.sentence(nb_words=4)
if group.description:
group.description = self.faker.text()
for status in self.session.query(TaskStatus):
status.status_comment = self.faker.sentence(nb_words=6)
def _an_task_config(self):
from autonomie.models.task import (
PaymentConditions,
)
for i in self.session.query(PaymentConditions):
self.session.delete(i)
for index, label in enumerate(
[u"30 jours fin de mois", u"À réception de facture"]
):
condition = PaymentConditions(label=label)
if index == 0:
condition.default = True
self.session.add(condition)
def _an_user(self):
from autonomie.models.user.login import (
Login,
)
from autonomie.models.user.user import (
User,
)
self.session.execute("Update accounts set session_datas='{}'")
counter = itertools.count()
found_contractor = False
for u in self.session.query(Login).join(User).filter(Login.active==True):
index = counter.next()
if index == 1:
u.login = u"admin1"
u.groups = ['admin']
elif index == 2:
u.login = u"manager1"
u.groups = ["manager"]
elif not found_contractor and "contractor" in u.groups:
u.login = u"entrepreneur1"
found_contractor = True
else:
u.login = u"user_{0}".format(index)
u.user.lastname = self.faker.last_name()
u.user.firstname = self.faker.first_name()
u.user.email = self.faker.ascii_safe_email()
u.set_password(u.login)
if u.user.has_userdatas():
u.user.userdatas.coordonnees_lastname = u.user.lastname
u.user.userdatas.coordonnees_firstname = u.user.firstname
u.user.userdatas.coordonnees_email1 = u.user.email
for u in self.session.query(Login).join(User).filter(Login.active==False
):
index = counter.next()
u.login = u"user_{0}".format(index)
u.user.lastname = self.faker.last_name()
u.user.firstname = self.faker.first_name()
u.user.email = self.faker.ascii_safe_email()
u.set_password(u.login)
if u.user.has_userdatas():
u.user.userdatas.coordonnees_lastname = u.user.lastname
u.user.userdatas.coordonnees_firstname = u.user.firstname
u.user.userdatas.coordonnees_email1 = u.user.email
def _an_userdatas(self):
from autonomie.models.user.userdatas import (
UserDatas,
CompanyDatas,
AntenneOption,
)
for u in self.session.query(UserDatas):
if u.user_id is None:
u.coordonnees_lastname = self.faker.last_name()
u.coordonnees_firstname = self.faker.first_name()
u.coordonnees_email1 = self.faker.ascii_safe_email()
u.coordonnees_ladies_lastname = self.faker.last_name_female()
u.coordonnees_email2 = self.faker.ascii_safe_email()
u.coordonnees_tel = self.faker.phone_number()[:14]
u.coordonnees_mobile = self.faker.phone_number()[:14]
u.coordonnees_address = self.faker.street_address()
u.coordonnees_zipcode = self._zipcode()
u.coordonnees_city = self.faker.city()
u.coordonnees_birthplace = self.faker.city()
u.coordonnees_birthplace_zipcode = self._zipcode()
u.coordonnees_secu = u"0 00 00 000 000 00"
u.coordonnees_emergency_name = self.faker.name()
u.coordonnees_emergency_phone = self.faker.phone_number()[:14]
u.parcours_goals = self.faker.text()
for datas in self.session.query(CompanyDatas):
datas.title = self.faker.company()
datas.name = self.faker.company()
datas.website = self.faker.url()
for a in AntenneOption.query():
a.label = u"Antenne : {0}".format(self.faker.city())
def _an_files(self):
from autonomie.models.files import File
for file_ in self.session.query(File):
self.session.delete(file_)
from autonomie.models.files import Template
sample_tmpl_path = os.path.abspath(
pkg_resources.resource_filename('autonomie', 'sample_templates')
)
for filename in os.listdir(sample_tmpl_path):
filepath = os.path.join(sample_tmpl_path, filename)
with open(filepath, 'r') as fbuf:
tmpl = Template(name=filename, description=filename)
tmpl.data = fbuf.read()
self.session.add(tmpl)
def _an_celery_jobs(self):
self.session.execute("delete from mailing_job")
self.session.execute("delete from file_generation_job")
self.session.execute("delete from csv_import_job")
self.session.execute("delete from job")
def _an_task_mentions(self):
from autonomie.models.task.mentions import TaskMention
for mention in TaskMention.query():
mention.full_text = self.faker.paragraph(nb_sentences=3)
self.session.merge(mention)
def run(self, module_key=None):
if module_key is not None:
if not module_key.startswith('_an_'):
module_key = u"_an_%s" % module_key
keys = [module_key]
methods = {module_key: getattr(self, module_key)}
else:
methods = {}
for method_name, method in inspect.getmembers(
self,
inspect.ismethod
):
if method_name.startswith('_an_'):
methods[method_name] = method
keys = methods.keys()
keys.sort()
for key in keys:
self.logger.debug(u"Step : {0}".format(key))
methods[key]()
transaction.commit()
transaction.begin()
from dal_opt.db import session_factory, GoodUser, BadUser
from faker import Faker
import uuid
session = session_factory()
for x in range(100000):
f = Faker()
name = f.name()
address = f.address()
comment = f.text()
id = uuid.uuid4()
bad_user = BadUser(id=str(id),
name=name,
address=address,
comment=comment)
good_user = GoodUser(id=id,
name=name,
address=address,
comment=comment)
session.add(bad_user)
session.add(good_user)
session.commit()
class TestHyAM(unittest.TestCase):
""" Tests addresses in the hy_AM locale """
def setUp(self):
self.factory = Faker('hy_AM')
def test_address(self):
address = self.factory.address()
assert isinstance(address, string_types)
def test_building_number(self):
building_number = self.factory.building_number()
assert isinstance(building_number, string_types)
assert len(building_number) <= 3
def test_city(self):
city = self.factory.city()
assert isinstance(city, string_types)
assert city in HyAmProvider.cities
def test_city_prefix(self):
city_prefix = self.factory.city_prefix()
assert isinstance(city_prefix, string_types)
assert city_prefix in HyAmProvider.city_prefixes
def test_city_suffix(self):
city_suffix = self.factory.city_suffix()
assert isinstance(city_suffix, string_types)
def test_country(self):
country = self.factory.country()
assert isinstance(country, string_types)
assert country in HyAmProvider.countries
def test_alpha_2_country_codes(self):
country_code = Faker().country_code(representation='alpha-2')
assert len(country_code) == 2
assert country_code.isalpha()
def test_alpha_2_country_codes_as_default(self):
country_code = Faker().country_code()
assert len(country_code) == 2
assert country_code.isalpha()
def test_alpha_3_country_codes(self):
country_code = Faker().country_code(representation='alpha-3')
assert len(country_code) == 3
assert country_code.isalpha()
def test_bad_country_code_representation(self):
with self.assertRaises(ValueError):
Faker().country_code(representation='hello')
def test_postcode(self):
postcode = self.factory.postcode()
assert isinstance(postcode, string_types)
assert re.match(r"\d{4}", postcode)
assert int(postcode) >= 200
assert int(postcode) <= 4299
def test_postcode_in_state(self):
for state_abbr in HyAmProvider.states_abbr:
code = self.factory.postcode_in_state(state_abbr)
assert re.match(r"\d{4}", code)
assert int(code) >= HyAmProvider.states_postcode[state_abbr][0]
assert int(code) <= HyAmProvider.states_postcode[state_abbr][1]
with self.assertRaises(Exception):
self.factory.postcode_in_state('XX')
def test_secondary_address(self):
secondary_address = self.factory.secondary_address()
assert isinstance(secondary_address, string_types)
def test_state(self):
state = self.factory.state()
assert isinstance(state, string_types)
assert state in HyAmProvider.states
def test_state_abbr(self):
state_abbr = self.factory.state_abbr()
assert isinstance(state_abbr, string_types)
assert state_abbr in HyAmProvider.states_abbr
assert state_abbr.isupper()
def test_street(self):
street = self.factory.street()
assert isinstance(street, string_types)
assert street in HyAmProvider.streets
def test_street_address(self):
street_address = self.factory.street_address()
assert isinstance(street_address, string_types)
def test_street_name(self):
street_name = self.factory.street_name()
assert isinstance(street_name, string_types)
def test_street_prefix(self):
street_prefix = self.factory.street_prefix()
assert isinstance(street_prefix, string_types)
assert street_prefix in HyAmProvider.street_prefixes
def test_street_suffix(self):
suffix = self.factory.street_suffix()
assert isinstance(suffix, string_types)
assert suffix in HyAmProvider.street_suffixes
def test_village(self):
village = self.factory.village()
assert isinstance(village, string_types)
assert village in HyAmProvider.villages
def test_village_prefix(self):
village_prefix = self.factory.village_prefix()
assert isinstance(village_prefix, string_types)
assert village_prefix in HyAmProvider.village_prefixes
#generaData.py from faker import Faker f = Faker() for i in xrange(5): print print "nombre: ", f.name() print "usuario: ", f.user_name() print "email: ", f.email() print "cia: ", f.company() print "tel: ", f.phone_number() print "direccion: ", f.address() print "tarjeta: ", f.credit_card_security_code(card_type=None)
import pandas as pd
from faker import Faker
import bcrypt
fake = Faker()
data = pd.read_csv('companies.csv')
for comName in data.columns:
name = fake.name().split()
u = models.User(first_name=name[0],last_name=name[1],email=fake.email(),password=bcrypt.hashpw('heythere'.encode('UTF_8'),bcrypt.gensalt(14)))
p = models.Profile(user=u)
c = models.Company(owner=u,name=comName,address=fake.address())
db.session.add(u)
db.session.add(p)
db.session.add(c)
db.session.commit()
for job in data[comName]:
if pd.isnull(job):
break
db.session.add(models.Job(title=job,company=c))
db.session.commit()
# for i in range(data[0,:].size):
# name = fake.name().split()
# u = models.User(first_name=name[0],last_name=name[1],email=fake.email(),password=bcrypt.hashpw('heythere'.encode('UTF_8'),bcrypt.gensalt(14)))
def genData():
foo = name_generator.NameGenerator()
fake = Faker()
occGenerator = randomOccGenerator()
outData = open("rawGen.txt","w")
labelsOut = open("labelsGen.txt","w")
for i in range(10):
print i
middle = copy.deepcopy(vary)
random.shuffle(middle) #shuffle the elements of each string for the current page
if random.random() < .99: ## ESTIMATE: gender in 1% of data
middle.remove("gender")
aff_format = 1 ## Affliation format: 1 means one character, 2 means 3 characters
if random.random() < .5:
aff_format = 2
fmt = ["name"]
for ent in middle:
fmt.append(ent)
fmt.append("aff")
page = ""
labels = []
new_header = corrupt(header)
page +=new_header
tags = [7] * len(new_header)
labels.extend(tags)
for j in range(100):
new_labels = []
out = ""
for elt in fmt:
if elt == "name":
lastname,title,firstname,gender= getName(foo)
namestr = lastname+title+firstname
tags = [2] * len(namestr)
new_labels.extend(tags)
out+=namestr+ " "
new_labels.append(1)
if elt == "addr": #generate address
address = fake.address().split('\n', 1)[0]
tags = [3] * len(address)
new_labels.extend(tags)
out+=address + " "
new_labels.append(1)
if elt == "occ": #genearte occupation
occ = occGenerator.occ()
tags = [4] * len(occ)
new_labels.extend(tags)
out+= occ + " "
new_labels.append(1)
if elt == "gender":
tags = [5] * len(gender)
new_labels.extend(tags)
out+= gender + " "
new_labels.append(1)
if elt == "aff":
aff = getAff(aff_format)
tags = [6] * len(aff)
new_labels.extend(tags)
out+= aff + " "
new_labels.append(0)
assert len(out) == len(new_labels), "Incorrect number of labels created"
out = corrupt(out)
labels.extend(new_labels)
page+=out
labelstr = ' '.join([str(i) for i in labels])+"\n"
for c in page:
outData.write("{}".format(ord(c))+" ")
outData.write("\n")
# pasgestr = ' '.join(list(page))+"\n"
# outData.write(page)
labelsOut.write(labelstr)
# print page
# print len(list(page)),len(labels)
# firstname, lastname = foo.generate_name("m")
# print firstname, lastname
# firstname, lastname = foo.generate_name("f")
# print firstname, lastname
return
assert r.status_code == 201
# AUTH
def hash_password(password: str, secret_key: str) -> str:
import hashlib
m = hashlib.sha256()
m.update(secret_key.encode())
m.update(password.encode())
return m.hexdigest()
SECRET_KEY = 'default-secret-key'
auth=HTTPBasicAuth(email, hash_password(password, SECRET_KEY))
# NEW ADDRESS
put_address_req = {'address': FAKER.address()}
print(put_address_req)
r = requests.put(BASE_URL + '/v1/address', json=put_address_req, auth=auth)
print(r.status_code, r.text)
address_id = r.json()['id']
print("new address id: ", address_id)
# NEW RIDE-REQUEST
put_ride_request_req = {'address_id': address_id}
print(put_ride_request_req)
r = requests.put(BASE_URL + '/v1/ride_request', json=put_ride_request_req, auth=auth)
print(r.status_code, r.text)
# LIST RIDE-REQUEST
r = requests.get(BASE_URL + '/v1/ride_request', auth=auth)
print(r.text)
import boto.dynamodb
conn = boto.dynamodb.connect_to_region('<Region_Name>')
table = conn.get_table('<DynamoDB_Table_Name>')
fake = Faker()
shippingmethodarray = ['1-hour','1-day','2-days','1-hour','1-day','1-hour','1-day','1-hour','1-day','1-day','1-day','2-day','1-week']
orderqtyarray = [1,2,2,3,1,1,2,2,2,3,4,5,6,7,1,1,1,1,1,1,1,1,2]
priceRange = ['1,10','1,10','1,10','1,10','11,20','11,20','21,30','31,40','11,20','11,20','11,20','21,30','11,20','21,30','41,50','51,60','61,70','71,80','81,90','11,20','1,10']
productCategoryarray = ['Toys','Books','Movies','Electronics','Clothing','Sports','Healthcare','Toys','Electronics','Electronics','Electronics','Toys','Healthcare']
while 1:
orderId = str(uuid.uuid4())
orderDate = int(strftime("%Y%m%d%H%M%S"))
shipMethod = str(random.choice(shippingmethodarray))
fullAddress = str(fake.address())
billAddress = str(fullAddress).replace('\n',' ').replace(',',' ')
billCity = str(fullAddress.rsplit(' ', 1)[-2].split(' ')[-1])
billPostalCode = int(fullAddress.rsplit(' ', 1)[-1].split('-')[0])
orderQty = int(random.choice(orderqtyarray))
unitPriceRange = random.choice(priceRange)
unitPrice = random.randint(int(unitPriceRange.split(',')[0]),int(unitPriceRange.split(',')[1]))
productCategory = str(random.choice(productCategoryarray))
item_data = {
'OrderDate' : orderDate,
'ShipMethod' : shipMethod,
'BillAddress' : billAddress,
'BillCity' : billCity,
'BillPostalCode' : billPostalCode,
'OrderQty' : orderQty,
'UnitPrice' : unitPrice,
class Command(BaseCommand):
help = 'Add fake data to the database.'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.faker = Faker()
self.faker.add_provider(UniqueUrlProvider)
def add_arguments(self, parser):
parser.add_argument(
'--seed', action='store', default=None,
help='Provide an initial seed for randomization mechanism.',
)
def fake_airports(self):
"""Add some airports."""
# we're not doing anything here, since:
# 1. data migrations add some airports already
# 2. we'll have more airports as fixtures as of #626
pass
def fake_roles(self):
self.stdout.write('Generating fake roles...')
roles = [
('helper', 'Helper'),
('instructor', 'Instructor'),
('host', 'Workshop host'),
('learner', 'Learner'),
('organizer', 'Workshop organizer'),
('contributor', 'Contributed to lesson materials')
]
"""Provide fixed roles (before they end up in fixtures, see #626)."""
for name, verbose_name in roles:
Role.objects.create(name=name, verbose_name=verbose_name)
def fake_groups(self):
# Two groups are already in the migrations: Administrator
# and Steering Committee
self.stdout.write('Generating fake groups...')
Group.objects.create(name='invoicing')
Group.objects.create(name='trainers')
def fake_tags(self):
"""Provide fixed tags (before they end up in fixtures, see #626)."""
self.stdout.write('Generating fake tags...')
tags = [
('SWC', 'Software Carpentry Workshop'),
('DC', 'Data Carpentry Workshop'),
('LC', 'Library Carpentry Workshop'),
('WiSE', 'Women in Science and Engineering'),
('TTT', 'Train the Trainers'),
]
for tag, details in tags:
Tag.objects.create(name=tag, details=details)
def fake_badges(self):
"""Provide fixed badges (before they end up in fixtures, see #626)."""
# 4 badges are already in the migrations: swc-instructor,
# dc-instructor, maintainer, and trainer
self.stdout.write('Generating fake badges...')
badges = [
('creator', 'Creator',
'Creating learning materials and other content'),
('member', 'Member', 'Software Carpentry Foundation member'),
('organizer', 'Organizer',
'Organizing workshops and learning groups'),
]
for name, title, criteria in badges:
Badge.objects.create(name=name, title=title, criteria=criteria)
def fake_instructors(self, count=30):
self.stdout.write('Generating {} fake instructors...'.format(count))
for _ in range(count):
self.fake_person(is_instructor=True)
def fake_trainers(self, count=10):
self.stdout.write('Generating {} fake trainers...'.format(count))
for _ in range(count):
self.fake_person(is_instructor=True, is_trainer=True)
def fake_admins(self, count=10):
self.stdout.write('Generating {} fake admins...'.format(count))
for _ in range(count):
person = self.fake_person(is_instructor=randbool(0.5))
person.groups.add(choice(Group.objects.all()))
person.is_active = True
person.set_password(person.username)
person.save()
def fake_trainees(self, count=30):
self.stdout.write('Generating {} fake trainees '
'(and their training progresses '
'as well as training requests)...'.format(count))
for _ in range(count):
p = self.fake_person(is_instructor=randbool(0.1))
training = choice(Event.objects.ttt())
Task.objects.create(person=p, event=training,
role=Role.objects.get(name='learner'))
self.fake_training_progresses(p, training)
if randbool(0.8):
self.fake_training_request(p)
def fake_training_progresses(self, p, training):
trainers = Person.objects.filter(award__badge__name='trainer')
for r in TrainingRequirement.objects.all():
if randbool(0.4):
if 'Homework' in r.name and randbool(0.5):
state = 'n'
else:
state = 'p' if randbool(0.95) else 'f'
evaluated_by = None if state == 'n' else choice(trainers)
event = training if r.name == 'Training' else None
url = self.faker.url() if 'Homework' in r.name else None
TrainingProgress.objects.create(
trainee=p,
requirement=r,
evaluated_by=evaluated_by,
state=state,
discarded=randbool(0.05),
event=event,
url=url,
notes='',
)
def fake_training_request(self, person_or_None):
if person_or_None is None:
state = 'p' if randbool(0.5) else 'd'
person = self.fake_person(is_instructor=False)
else:
state = 'a'
person = person_or_None
occupation = choice(ProfileUpdateRequest.OCCUPATION_CHOICES)[0]
req = TrainingRequest.objects.create(
state=state,
person=person_or_None,
group_name=self.faker.city() if randbool(0.1) else '',
personal=person.personal,
middle='',
family=person.family,
email=person.email,
github=person.github,
occupation=occupation,
occupation_other=self.faker.job() if occupation == '' else '',
affiliation=person.affiliation,
location=self.faker.city(),
country=choice(Countries)[0],
domains_other='',
gender=person.gender,
gender_other='',
previous_training=choice(
TrainingRequest.PREVIOUS_TRAINING_CHOICES)[0],
previous_training_other='',
previous_training_explanation=self.faker.text(),
previous_experience=choice(
TrainingRequest.PREVIOUS_EXPERIENCE_CHOICES)[0],
previous_experience_other='',
programming_language_usage_frequency=choice(
TrainingRequest.PROGRAMMING_LANGUAGE_USAGE_FREQUENCY_CHOICES)[0],
reason=self.faker.text(),
teaching_frequency_expectation=choice(
TrainingRequest.TEACHING_FREQUENCY_EXPECTATION_CHOICES)[0],
teaching_frequency_expectation_other='',
max_travelling_frequency=choice(
TrainingRequest.MAX_TRAVELLING_FREQUENCY_CHOICES)[0],
max_travelling_frequency_other='',
additional_skills=self.faker.job() if randbool(0.2) else '',
comment=self.faker.text() if randbool(0.3) else '',
)
req.domains = sample(KnowledgeDomain.objects.all())
req.previous_involvement = sample(Role.objects.all())
if person_or_None is None:
person.delete()
def fake_person(self, *, is_instructor, is_trainer=False):
airport = choice(Airport.objects.all())
email = choice([self.faker.email(),
self.faker.safe_email(),
self.faker.free_email(),
self.faker.company_email()])
gender = choice(Person.GENDER_CHOICES)[0]
if gender == 'F':
personal_name = self.faker.first_name_female()
family_name = self.faker.last_name_female()
elif gender == 'M':
personal_name = self.faker.first_name_male()
family_name = self.faker.last_name_male()
else:
personal_name = self.faker.first_name()
family_name = self.faker.last_name()
social_username = self.faker.user_name()
if randbool(0.6):
# automatically generate username
username = create_username(personal_name, family_name)
else:
# assume that the username is provided by the person
username = social_username
github = social_username if randbool(0.5) else None
twitter = social_username if randbool(0.5) else None
url = self.faker.url() if randbool(0.5) else ''
person = Person.objects.create(
personal=personal_name,
family=family_name,
email=email,
gender=gender,
may_contact=randbool(0.5),
airport=airport,
twitter=twitter,
github=github,
url=url,
username=username,
)
if is_instructor:
# Add one or more instructor badges
awards = []
badges = sample(Badge.objects.instructor_badges())
for badge in badges:
date = self.faker.date_time_between(start_date='-5y').date()
awards.append(Award(person=person, badge=badge, awarded=date))
Award.objects.bulk_create(awards)
if randbool(0.75):
# Add one or more qualifications
Qualification.objects.bulk_create(
Qualification(person=person, lesson=lesson)
for lesson in sample(Lesson.objects.all())
)
if is_trainer:
date = self.faker.date_time_between(start_date='-5y').date()
trainer = Badge.objects.get(name='trainer')
Award.objects.create(person=person, badge=trainer, awarded=date)
return person
def fake_organizations(self, count=10):
"""Add some organizations that host events."""
self.stdout.write('Generating {} fake organizations...'.format(count))
for _ in range(count):
Organization.objects.create(
domain=self.faker.domain_name(),
fullname=self.faker.company(),
country=choice(Countries)[0],
)
def fake_memberships(self, count=10):
self.stdout.write('Generating {} fake memberships...'.format(count))
for _ in range(count):
start = self.faker.date_time_between(start_date='-5y').date()
Membership.objects.create(
variant=choice(Membership.MEMBERSHIP_CHOICES),
agreement_start=start,
agreement_end=start + timedelta(days=365),
contribution_type=choice(Membership.CONTRIBUTION_CHOICES),
workshops_without_admin_fee_per_year=randint(5, 15),
self_organized_workshops_per_year=randint(5, 15),
notes='',
organization=choice(Organization.objects.all()),
)
def fake_current_events(self, count=5, **kwargs):
"""Ongoing and upcoming events."""
self.stdout.write('Generating {} fake current events...'.format(count))
for _ in range(count):
self.fake_event(**kwargs)
def fake_uninvoiced_events(self, count=5):
"""Preferably in the past, and with 'uninvoiced' status."""
self.stdout.write(
'Generating {} fake uninvoiced events...'.format(count))
for _ in range(count):
e = self.fake_event()
e.invoice_status = 'not-invoiced'
e.save()
def fake_unpublished_events(self, count=5):
"""Events with missing location data (which is required for publishing
them)."""
self.stdout.write(
'Generating {} fake unpublished events...'.format(count))
for _ in range(count):
self.fake_event(location_data=False)
def fake_self_organized_events(self, count=5):
"""Full-blown events with 'self-organized' host."""
self.stdout.write(
'Generating {} fake self organized events...'.format(count))
for _ in range(count):
e = self.fake_event(self_organized=True)
e.invoice_status = choice(Event.INVOICED_CHOICES)[0]
e.save()
def fake_ttt_events(self, count=10):
self.stdout.write(
'Generating {} fake train-the-trainer events...'.format(count))
for _ in range(count):
e = self.fake_event()
e.slug += '-ttt'
e.tags.set([Tag.objects.get(name='TTT')])
e.save()
def fake_event(self, *, location_data=True, self_organized=False,
add_tags=True):
start = self.faker.date_time_between(start_date='-5y').date()
city = self.faker.city().replace(' ', '-').lower()
if self_organized:
org = Organization.objects.get(domain='self-organized')
else:
org = choice(Organization.objects.exclude(domain='self-organized'))
# The following line may result in IntegrityError from time to time,
# because we don't guarantee that the url is unique. In that case,
# simply create new database (rm db.sqlite3 && python manage.py migrate)
# and rerun fake_database command (python manage.py fake_database). Be
# aware that creating a database deletes all data in the existing
# database!
e = Event.objects.create(
slug='{:%Y-%m-%d}-{}'.format(start, city),
start=start,
end=start + timedelta(days=2),
url=self.faker.unique_url(),
host=org,
# needed in order for event to be published
country=choice(Countries)[0] if location_data else None,
venue=self.faker.word().title() if location_data else '',
address=self.faker.street_address() if location_data else '',
latitude=uniform(-90, 90) if location_data else None,
longitude=uniform(0, 180) if location_data else None,
metadata_changed=randbool(0.1),
)
if add_tags:
e.tags = sample(Tag.objects.exclude(name='TTT'), 2)
return e
def fake_tasks(self, count=120):
self.stdout.write('Generating {} fake tasks...'.format(count))
events = Event.objects.all()
persons = Person.objects.all()
roles = Role.objects.all()
all_possible = itertools.product(events, persons, roles)
for event, person, role in sample(all_possible, count):
Task.objects.create(
event=event,
person=person,
role=role,
title=(self.faker.sentence(nb_words=4, variable_nb_words=True)
if randbool(0.2) else ''),
url=self.faker.url() if randbool(0.2) else '',
)
def fake_unmatched_training_requests(self, count=20):
self.stdout.write('Generating {} fake unmatched '
'training requests...'.format(count))
for _ in range(count):
self.fake_training_request(None)
def fake_duplicated_people(self, count=5):
self.stdout.write('Generating {} fake '
'people duplications...'.format(count))
for _ in range(count):
p = Person.objects.order_by('?').first()
p.id = None
# avoid integrity errors due to unique constraints
p.username = create_username(p.personal, p.family)
p.twitter = None
p.github = None
p.email = self.faker.email()
p.save()
def fake_workshop_requests(self, count=10):
self.stdout.write('Generating {} fake '
'workshop requests...'.format(count))
for _ in range(count):
if randbool(0.5):
language = Language.objects.get(subtag='en')
else:
language = choice(Language.objects.all())
req = EventRequest.objects.create(
name=self.faker.name(),
email=self.faker.email(),
affiliation=self.faker.company(),
location=self.faker.city(),
country=choice(Countries)[0],
conference='',
preferred_date=str(self.faker.date_time_between(
start_date='now', end_date='+1y').date()),
language=language,
workshop_type=choice(EventRequest.WORKSHOP_TYPE_CHOICES)[0],
approx_attendees=choice(
EventRequest.ATTENDEES_NUMBER_CHOICES)[0],
attendee_domains_other='',
data_types=choice(EventRequest.DATA_TYPES_CHOICES)[0],
understand_admin_fee=True,
admin_fee_payment=choice(
EventRequest.ADMIN_FEE_PAYMENT_CHOICES)[0],
fee_waiver_request=randbool(0.2),
cover_travel_accomodation=randbool(0.6),
travel_reimbursement=choice(
EventRequest.TRAVEL_REIMBURSEMENT_CHOICES)[0],
travel_reimbursement_other='',
comment='',
)
req.attendee_domains = sample(KnowledgeDomain.objects.all())
req.attendee_academic_levels = sample(AcademicLevel.objects.all())
req.attendee_computing_levels = sample(
ComputingExperienceLevel.objects.all())
req.attendee_data_analysis_level = sample(
DataAnalysisLevel.objects.all())
req.save()
def fake_workshop_submissions(self, count=10):
self.stdout.write('Generating {} fake '
'workshop submissions...'.format(count))
for _ in range(count):
EventSubmission.objects.create(
url=self.faker.url(),
contact_name=self.faker.name(),
contact_email=self.faker.email(),
self_organized=randbool(0.5),
notes='',
)
def fake_dc_selforganized_workshop_requests(self, count=5):
self.stdout.write('Generating {} fake dc self-organized '
'workshops requests...'.format(count))
for _ in range(count):
date = self.faker.date_time_between(start_date='now',
end_date='+1y')
req = DCSelfOrganizedEventRequest.objects.create(
name=self.faker.name(),
email=self.faker.email(),
organization=self.faker.company(),
instructor_status=choice(
DCSelfOrganizedEventRequest.INSTRUCTOR_CHOICES)[0],
is_partner=choice(
DCSelfOrganizedEventRequest.PARTNER_CHOICES)[0],
is_partner_other='',
location=self.faker.city(),
country=choice(Countries)[0],
associated_conference='',
dates=str(date.date()),
domains_other='',
topics_other='',
payment=choice(DCSelfOrganizedEventRequest.PAYMENT_CHOICES)[0],
fee_waiver_reason='',
handle_registration=True,
distribute_surveys=True,
follow_code_of_conduct=True,
)
req.domains = sample(DCWorkshopDomain.objects.all())
req.topics = sample(DCWorkshopTopic.objects.all())
req.attendee_academic_levels = sample(AcademicLevel.objects.all())
req.attendee_data_analysis_level = sample(
DataAnalysisLevel.objects.all())
def fake_profile_update_requests(self, count=20):
self.stdout.write('Generating {} fake '
'profile update requests...'.format(count))
for _ in range(count):
p = Person.objects.order_by('?').first() # type: Person
req = ProfileUpdateRequest.objects.create(
active=randbool(0.5),
personal=(p.personal if randbool(0.9)
else self.faker.first_name()),
middle=p.middle,
family=p.family if randbool(0.9) else self.faker.last_name(),
email=p.email if randbool(0.8) else self.faker.email(),
affiliation=(p.affiliation if randbool(0.8)
else self.faker.company()),
airport_iata=(p.airport.iata
if randbool(0.9) and p.airport is not None
else choice(Airport.objects.all()).iata),
occupation=choice(ProfileUpdateRequest.OCCUPATION_CHOICES)[0],
occupation_other='',
github=p.github or '',
twitter=p.twitter or '',
orcid=p.orcid or '',
website=p.url or '',
gender=choice(ProfileUpdateRequest.GENDER_CHOICES)[0],
gender_other='',
domains_other='',
lessons_other='',
notes='',
)
req.domains = (p.domains.all() if randbool(0.9) else
sample(KnowledgeDomain.objects.all()))
req.languages = (p.languages.all() if randbool(0.9) else
sample(Language.objects.all()))
req.lessons = (p.lessons.all() if randbool(0.9) else
sample(Lesson.objects.all()))
def fake_invoice_requests(self, count=10):
self.stdout.write('Generating {} fake '
'invoice requests...'.format(count))
for _ in range(count):
status = choice(InvoiceRequest.STATUS_CHOICES)[0]
sent_date = (None if status == 'not-invoiced' else
self.faker.date_time_between(start_date='-1y').date())
paid_date = (
self.faker.date_time_between(start_date=sent_date).date()
if status == 'paid' else None)
org = Organization.objects.order_by('?').first()
event = (Event.objects.order_by('?').first()
if randbool(0.8) else None)
req = InvoiceRequest.objects.create(
status=status,
sent_date=sent_date,
paid_date=paid_date,
organization=org,
reason=choice(InvoiceRequest.INVOICE_REASON)[0],
reason_other='',
date=(self.faker.date_time_between(start_date='-1y').date()
if sent_date is None else sent_date),
event=event,
event_location='',
item_id='',
postal_number='',
contact_name=org.fullname,
contact_email=self.faker.email(),
contact_phone='',
full_address=self.faker.address(),
amount=choice([1000, 2000, 10000]),
currency=choice(InvoiceRequest.CURRENCY)[0],
currency_other='',
breakdown='',
vendor_form_required=
choice(InvoiceRequest.VENDOR_FORM_CHOICES)[0],
vendor_form_link='',
form_W9=randbool(0.5),
receipts_sent=choice(InvoiceRequest.RECEIPTS_CHOICES)[0],
shared_receipts_link='',
notes='',
)
def handle(self, *args, **options):
seed = options['seed']
if seed is not None:
self.faker.seed(seed)
self.fake_airports()
self.fake_roles()
self.fake_groups()
self.fake_tags()
self.fake_badges()
self.fake_instructors()
self.fake_trainers()
self.fake_admins()
self.fake_organizations()
self.fake_memberships()
self.fake_current_events()
self.fake_uninvoiced_events()
self.fake_unpublished_events()
self.fake_self_organized_events()
self.fake_ttt_events()
self.fake_tasks()
self.fake_trainees()
self.fake_unmatched_training_requests()
self.fake_duplicated_people()
self.fake_workshop_requests()
self.fake_workshop_submissions()
self.fake_dc_selforganized_workshop_requests()
self.fake_profile_update_requests()
self.fake_invoice_requests()
import csv, math, random, re, string
from faker import Faker
fake = Faker()
au = list(string.ascii_uppercase)
ad = list(string.digits)
distance = int(input('Set distance of speed checking zone (m): '))
speedLimit = int(input('Set speed limit of speed checking zone (km/h): '))
deltaTime = speedLimit/distance
lst = []
for i in range(0,99):
lst.append([])
fake = Faker()
name = fake.name()
address = fake.address()
lst[i].append(name)
lst[i].append(address)
lst[i].append(au[random.randint(0, len(au)-1)]+au[random.randint(0, len(au)-1)]+ad[random.randint(0, len(ad)-1)]+ad[random.randint(0, len(ad)-1)]+' '+au[random.randint(0, len(au)-1)]+au[random.randint(0, len(au)-1)]+au[random.randint(0, len(au)-1)])
speed = speedLimit + random.randint(-10, 10)
randDeltaTime = round(distance/speed)
print (randDeltaTime)
time1 = random.randint(0,86400)
time2 = time1 + randDeltaTime
m1, s1 = divmod(time1, 60)
h1, m1 = divmod(m1, 60)
time1 = "%d:%02d:%02d" % (h1, m1, s1)
m2, s2 = divmod(time2, 60)
h2, m2 = divmod(m2, 60)
#!/usr/bin/env python from faker import Faker fake = Faker() print fake.name() print fake.address() print fake.text()
def address_data(self, ty, length):
res = []
f = Faker()
for _ in range(0, length - 1):
res.append(f.address())
return pd.Series(res)
def __iter__(self):
for item in self.previous:
yield item
amount = int(self.options.get('amount', '0'))
fake = Faker()
for i in range(amount):
yield {
'name': fake.name(),
'address': fake.address()
}
