def insert_random_client(cursor):
global clients_counter, client_fields_counter
clients_counter += 1
first_name = faker.first_name()
last_name = faker.last_name()
phone = faker.random_number(9, fix_len=True)
email = '{}.{}@gmail.com'.format(first_name, last_name)
conference = faker.boolean()
pesel = faker.random_number(11, fix_len=True)
address = faker.address()
cursor.execute('INSERT INTO clients '
'(id, first_name, last_name, phone, email, conference) '
'VALUES ({}, \'{}\', \'{}\', \'{}\', \'{}\', {})'.format(
clients_counter, first_name, last_name, phone, email,
conference))
client_fields_counter += 1
cursor.execute('INSERT INTO client_fields '
'(id, client_id, type, value) '
'VALUES ({}, {}, \'{}\', \'{}\')'.format(
client_fields_counter, clients_counter, 'PESEL', pesel))
client_fields_counter += 1
cursor.execute('INSERT INTO client_fields '
'(id, client_id, type, value) '
'VALUES ({}, {}, \'{}\', \'{}\')'.format(
client_fields_counter, clients_counter, 'ADDRESS',
address))
class UserFactory(DjangoModelFactory):
first_name = lazy_attribute(lambda o: faker.first_name())
last_name = lazy_attribute(lambda o: faker.last_name())
# username = lazy_attribute(lambda o: slugify(o.first_name + '.' + o.last_name))
username = factory.Sequence(lambda n: 'user%d' % n)
email = lazy_attribute(lambda o: o.username + "@example.com")
is_active = True
is_staff = False
is_superuser = False
password = factory.PostGenerationMethodCall('set_password', 'coygth14')
@factory.post_generation
def groups(self, create, extracted, **kwargs):
if not create:
# Simple build, do nothing.
return
if extracted:
# A list of groups were passed in, use them
self.groups.add(*extracted)
@lazy_attribute
def date_joined(self):
return timezone.now() - dt.timedelta(days=randint(5, 50))
last_login = lazy_attribute(lambda o: o.date_joined + dt.timedelta(days=4))
class Meta:
model = 'auth.User'
class UserFactory(DjangoModelFactory):
class Meta:
model = User
username = Sequence(lambda n: "user_{0}".format(n))
first_name = lazy_attribute(lambda a: faker.first_name())
last_name = lazy_attribute(lambda a: faker.last_name())
last_session_key = Sequence(lambda n: "session_{0}.dat".format(n))
class UserFactory(DjangoModelFactory):
class Meta:
model = User
username = lazy_attribute(lambda x: faker.user_name())
first_name = lazy_attribute(lambda x: faker.first_name())
last_name = lazy_attribute(lambda x: faker.last_name())
email = lazy_attribute(lambda x: faker.email())
password = lazy_attribute(lambda x: faker.password())
class UserFactory(factory.DjangoModelFactory):
class Meta:
model = User
first_name = factory.LazyAttribute(lambda o: faker.first_name())
last_name = factory.LazyAttribute(lambda o: faker.last_name())
email = factory.LazyAttribute(lambda a: '{0}.{1}@example.com'.format(
a.first_name, a.last_name).lower())
username = email
password = factory.PostGenerationMethodCall('set_password', '123456')
def test__add_or_update_user__existing_user__is_successful(db, s):
user = UserFactory()
db.add_or_update_user(s, user)
db_user = db.get_user_by_id(s, user.id)
user.first_name = faker.first_name()
user.last_name = faker.last_name()
user.username = f'{user.first_name}_{user.last_name}'.lower()
db.add_or_update_user(s, user)
for p in ('first_name', 'last_name', 'username'):
assert getattr(user, p) == getattr(db_user, p)
def seed_authors():
content_type = ContentType.objects.get(app_label='articles',
model='article')
create_article_permission, created = Permission.objects.get_or_create(
codename='can_create_articles',
defaults={
'name': 'Can create Articles',
'content_type': content_type
},
)
update_article_permission, created = Permission.objects.get_or_create(
codename='can_update_articles',
defaults={
'name': 'Can update Articles',
'content_type': content_type
},
)
delete_article_permission, created = Permission.objects.get_or_create(
codename='can_delete_articles',
defaults={
'name': 'Can delete Articles',
'content_type': content_type
},
)
authors_group, created = Group.objects.get_or_create(name='authors')
authors_group.permissions.add(create_article_permission)
authors_group.permissions.add(update_article_permission)
authors_group.permissions.add(delete_article_permission)
authors_count = AppUser.objects.filter(
groups__name__iexact='authors').count()
authors_to_seed = 5
sys.stdout.write('[+] Seeding %d authors\n' %
(authors_to_seed - authors_count))
for i in range(authors_count, authors_to_seed):
username = faker.profile(fields='username')['username']
first_name = faker.first_name()
last_name = faker.last_name()
email = faker.email()
password = '******'
# create_user instead of create, to hash
author = AppUser.objects.create_user(username=username,
first_name=first_name,
last_name=last_name,
email=email,
password=password)
author.groups.add(authors_group)
def seed_users():
users_count = AppUser.objects.count()
users_to_seed = 23
sys.stdout.write('[+] Seeding %d users\n' % (users_to_seed - users_count))
for i in range(users_count, users_to_seed):
username = faker.profile(fields='username')['username']
first_name = faker.first_name()
last_name = faker.last_name()
email = faker.email()
password = '******'
# create_user instead of create, to hash
AppUser.objects.create_user(username=username,
first_name=first_name,
last_name=last_name,
email=email,
password=password)
parser.add_argument('--num_users',
required=False,
default=10,
type=int,
help='number of users to create')
args = parser.parse_args()
if __name__ == '__main__':
faker = faker.Faker()
responses = []
print(args.num_users)
for i in range(0, args.num_users):
first_name = faker.first_name().lower()
last_name = faker.last_name().lower()
person_id = '{0}_{1}_test_user'.format(first_name, last_name)
person_password = '******'.format(first_name, last_name)
person_email = '{0}_{1}[email protected]'.format(
first_name, last_name)
headers = {
'Authorization': args.admin_key,
'content-type': 'application/json'
}
payload = json.dumps({
'name': person_id,
'email': person_email,
'password': person_password
})
response = requests.post('http://' + args.target +
"/api/3/action/user_create",
start_date = faker.date_between(start_date='-20y', end_date='now')
delta = datetime.timedelta(days=365 * random.randint(18, 40)) # 18y-40y
birth_date = start_date - delta
return {'birth_date': birth_date, 'start_date': start_date}
def salary_and_bonus():
salary = round(random.randint(90000, 120000) / 1000) * 1000
bonus_ratio = random.uniform(0.15, 0.2)
bonus = (salary * bonus_ratio / 500) * 500
return {'salary': salary, 'bonus': bonus}
data = dict()
data['first_name_and_gender'] = first_name_and_gender
data['last_name'] = lambda: {'last_name': faker.last_name()}
data['email_address'] = lambda: {'email_address': faker.email()}
data['ssn'] = lambda: {'ssn': faker.ssn()}
data['birth_data_and_start_date'] = birth_date_and_start_date
data['address'] = lambda: {'address': faker.address()}
data['office'] = lambda: {'office': faker.city()}
data['title'] = lambda: {'title': faker.job()}
data['salary_and_bonus'] = salary_and_bonus
# print([data[k]() for k in data.keys()])
for i in range(10):
result = [list(data[k]().values()) for k in data.keys()]
row = [item for sublist in result for item in sublist]
print(row)
from numpy import vectorize
import time
import tqdm
from multiprocessing.pool import Pool
damerau_levenshtein_distance = vectorize(damerau_levenshtein_distance)
doublemetaphone = vectorize(metaphone.doublemetaphone)
l = 3000_00
faker = faker.Faker()
gender = [random.choice(['m', 'f']) for _ in range(l)]
first_name = [
faker.first_name_male() if g == 'm' else faker.first_name_female()
for g in gender
]
last_name = [faker.last_name() for _ in range(l)]
birth_date = [
faker.date_of_birth(minimum_age=12, maximum_age=15) for _ in range(l)
]
data = dict(first_name=first_name,
last_name=last_name,
gender=gender,
birth_date=birth_date)
start = time.time()
df = DataFrame(data)
meta0 = doublemetaphone(df['first_name'])
meta1 = doublemetaphone(df['last_name'])