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'])