def __init__(self, locale: str = "en", user_id_start: int = 0, user_id_end: int = 1000, max_friends: int = 0, start_year: int = None, end_year: int = None, seed: int = None) -> object: self._locale = locale self._seed = seed if self._seed: self._generic = Generic(self._locale, self._seed) else: self._generic = Generic(self._locale) self._user_id_start = user_id_start self._user_id_end = user_id_end self._max_friends = max_friends assert self._user_id_start < self._user_id_end if start_year is None: self._start_year = 2015 else: self._start_year = start_year if end_year is None: self._end_year = 2019 else: self._end_year = end_year
def handle(self, *args, **options): generics = [Generic('ru'), Generic('uk'), Generic('en')] genders = [Gender.MALE, Gender.FEMALE] variants = list(product(generics, genders)) upload_to = User.avatar.field.upload_to # pathlib doesn't like trailing slash, so use os.path.join avatars_save_path = os.path.join(settings.BASE_DIR, upload_to) users_count = User.objects.count() for index in range(users_count, users_count + options['count']): generic, gender = choice(variants) user = User.objects.create_user( generic.person.email(), generic.person.name(gender=gender), generic.person.surname(gender=gender), f'password_{index + 1}', username=generic.person.identifier('id######@@'), birthday=datetime.strptime( generic.datetime.date(start=1975, end=2000, fmt='%d.%m.%Y'), '%d.%m.%Y'), gender=gender.value.capitalize()[0], status=generic.text.quote(), avatar=os.path.join( upload_to, download_image( url= f'{generic.internet.stock_image(width=300, height=300)}/{uuid4()}.jpg', # noqa save_path=avatars_save_path))) user.save()
def handle_language(lang: str): if lang == 'en_US': return Generic('en') elif lang == 'ru_RU': return Generic('ru') elif lang == 'uk_UA': return Generic('uk') print('incorrect language string') sys.exit(1)
def __init__(self, locale:str="en", seed:int = None): self._locale = locale self._seed = seed if self._seed: self._generic = Generic(self._locale, self._seed) else: self._generic = Generic(self._locale) self._user_id = 1000
def test_parse_comment_message(self): faker = Generic() # test with comments in the locales below # we're using Farsi instead of Arabic # as mimesis doesn't support Arabic yet ): for locale in ['EN', 'ES', 'FA', 'FR', 'RU']: current_locale = getattr(locales, locale) test_participant_id = faker.person.identifier('######') with self.subTest(current_locale=current_locale): with faker.text.override_locale(current_locale): test_comment = faker.text.sentence() sample_text = 'XA{}AA1AB2@{}'.format( test_participant_id, test_comment) result = parse_text(sample_text) (prefix, participant_id, exclamation, form_serial, responses, comment) = result self.assertEqual(prefix, 'XA') self.assertEqual(participant_id, test_participant_id) self.assertFalse(exclamation) self.assertEqual(responses, 'AA1AB2') self.assertEqual(comment, test_comment)
def get_dataframe(parameters, use_threads): # Initialize seeds if parameters.seed is not None: np.random.seed(parameters.seed) # For each column, use a generic Mimesis producer to create an Iterable # for generating data for i, column_params in enumerate(parameters.column_parameters): if column_params.dtype is None: column_params.generator = column_params.generator( Generic("en", seed=parameters.seed)) else: column_params.generator = column_params.generator() # Get schema for each column schema = pa.schema([ pa.field( name=str(i), type=pa.dictionary( index_type=pa.int64(), value_type=pa.from_numpy_dtype( type(next(iter(column_params.generator)))), ) if isinstance(column_params.dtype, str) and column_params.dtype == "category" else pa.from_numpy_dtype( type(next(iter(column_params.generator))) if column_params.dtype is None else column_params.dtype), nullable=column_params.null_frequency > 0, ) for i, column_params in enumerate(parameters.column_parameters) ]) # Initialize column data and which columns should be sorted column_data = [None] * len(parameters.column_parameters) columns_to_sort = [ str(i) for i, column_params in enumerate(parameters.column_parameters) if column_params.is_sorted ] # Generate data if not use_threads: for i, column_params in enumerate(parameters.column_parameters): column_data[i] = _generate_column(column_params, parameters.num_rows) else: pool = Pool(pa.cpu_count()) column_data = pool.starmap( _generate_column, [(column_params, parameters.num_rows) for i, column_params in enumerate(parameters.column_parameters)], ) pool.close() pool.join() # Convert to Pandas DataFrame and sort columns appropriately tbl = pa.Table.from_arrays( column_data, schema=schema, ) if columns_to_sort: tbl = tbl.to_pandas() tbl = tbl.sort_values(columns_to_sort) tbl = pa.Table.from_pandas(tbl, schema) return tbl
def create_data_provider_list(providers, size, max_tries=100, local=None, seed=None, encoding='utf-8'): from mimesis import Generic data = {} header = [] for ps in providers: if isinstance(ps, tuple): p = ps[0] u = ps[1] elif isinstance(ps, list): p = ps[0] u = ps[1] else: p = ps u = None if isinstance(p, str): generic = Generic(local, seed=seed) s = p.split('.') p = getattr(getattr(generic, s[0]), s[1]) p_name = p.__name__ header.append(p_name) data[p_name] = create_data_single_provider(p, size, uniquness=u, max_tries=max_tries, encoding=encoding) return header, data
def setUp(self): self.gen = Generic() self.new_user = User(first_name=self.gen.person.full_name().split()[0], last_name=self.gen.person.full_name().split()[1], email=self.gen.person.email(), raw_password=self.gen.person.password()) self.new_user.save()
def gen_account(n): g = Generic('en') r = random.Random() ts_base = int(time.mktime(datetime.date(2019, 1, 1).timetuple())) for i in range(n): account_id = unique_account_id(g) prod_code, prod_name = gen_prod(r) balance = r.uniform(1000.0, 5_000_000.0, 4) ts = int(r.uniform(0, 15_724_800, 0)) # 3600 * 24 * 182 tstr = {'$date': {'$numberLong': str((ts_base +ts)*1000)}} account = { 'accountId': account_id, 'nickName': g.person.name(), # use person name to proxy nickname 'prodCode': prod_code, 'prodName': prod_name, 'currency': 'THB', 'servicer': g.code.pin(), # 4 digits 'status' : '0', 'status_last_updated': tstr, 'balances': [ {'amount': balance, 'type': '0', 'creditFlag': False, 'last_updated': tstr}, {'amount': balance, 'type': '1', 'creditFlag': False, 'last_updated': tstr} ] } if n < 5 and sys.stdout.isatty(): print(json.dumps(account, indent=4, sort_keys=True)) else: print(json.dumps(account))
def _generate_fake_news(typ): g = Generic('en') fake = '' if typ == '1': fake = g.person.full_name() elif typ == '2': fake = g.person.occupation() elif typ == '3': fake = g.person.email() elif typ == '4': fake = g.internet.home_page() elif typ == '5': fake = g.person.telephone() elif typ == '6': fake = g.business.company() elif typ == '7': fake = g.text.title() elif typ == '8': fake = g.numbers.integer_number() elif typ == '9': fake = g.address.address() elif typ == '10': fake = g.datetime.datetime() else: fake = '----' return fake
def create_data(local=None, provider=None, method=None, max_unique=100, seed=None): generic = Generic(local, seed=seed) data={} for c in dir(generic): if not provider or provider == c: data[c]={} for cc in inspect.getmembers(getattr(generic,c), predicate=inspect.ismethod): if not cc[0].startswith("_"): if not method or method == cc[0]: d=set([]) max_tries=100 a = 0 try: while len(d)<max_unique: value = cc[1]() if value not in d: d.add(value) a=0 else: a += 1 if a > max_tries: break except Exception: pass data[c][cc[0]]=len(d) return data
def test_delete_book(session, db_user, db_book): g = Generic("en") user_id = db_user.id copy = Copy( asset_code="{}{}".format(g.code.locale_code()[:2], g.code.pin(mask="######")), library_item=db_book, shelf=g.code.pin(), has_cd_disk=g.development.boolean(), ) session.add(copy) session.commit() log = RentalLog( copy_id=copy.id, user_id=user_id, borrow_time=datetime.now(tz=pytz.utc), return_time=datetime.now(tz=pytz.utc), book_status=BookStatus.BORROWED, ) session.add(log) session.commit() authors = populate_authors(n=2) session.add_all(authors) db_book.authors = authors session.commit() assert User.query.get(user_id) is not None, "User does not exist" assert (RentalLog.query.filter_by( user_id=user_id).count() == 1), "RentalLog add failed" assert (Copy.query.filter_by( library_item=db_book).count() == 1), "Copy add failed" book_one = (Book.query.join( Author.books).filter(Author.id == authors[0].id).all()) book_two = (Book.query.join( Author.books).filter(Author.id == authors[1].id).all()) assert ( book_two[0].id == book_one[0].id), "Authors should write the same book" assert book_one[0].id == db_book.id, "Author does not point the right book" assert Book.query.get(db_book.id) is not None, "Book does not exist" session.delete(db_book) session.commit() assert Book.query.get(db_book.id) is None, "Book delete failed" assert (User.query.get(user_id) is not None), "User was deleted with the Book" assert (Copy.query.get(copy.id) is None), "Copy was not deleted with the Book" assert (Book.query.join( Author.books).filter(Author.id == authors[0].id).all() == [] ), "Author 0 should not contain the Book" assert (Book.query.join( Author.books).filter(Author.id == authors[1].id).all() == [] ), "Author 1 should not contain the Book" assert (RentalLog.query.get(log.id) is None), "RentalLog was not deleted with the Book"
def setUp(self): self.g = Generic() self.username = self.g.person.username() self.email = self.g.person.email() self.password = self.g.person.password() self.new_user = User(username=self.username, email=self.email, password=self.password)
def generic(locale): """ :param locale: :return: locale :rtype: object """ return Generic(locale)
def setUp(self): self.gen = Generic() self.payload = { 'first_name': self.gen.person.full_name().split()[0], 'last_name': self.gen.person.full_name().split()[1], 'email': self.gen.person.email(), 'password': self.gen.person.password() }
def setUp(self): self.gen = Generic() self.payload = { 'first_name': self.gen.person.full_name().split()[0], 'last_name': self.gen.person.full_name().split()[1], 'email': self.gen.person.email(), 'password': self.gen.person.password() } self.client.post('/auth/signup', data=self.payload)
def patientd(): """ patient dict sans id """ return { "nom": f.person.last_name(), "prenom": f.person.name(), "ddn": Generic().datetime.date(), # "sexe": random.choice(('f', 'm')), "sexe": f.person.gender()[0].lower(), }
def test_update_book(view_edit_book, client, login_form_admin_credentials, mock_ldap): with mock.patch('views.index.ldap_client', mock_ldap): languages = ['polish', 'english', 'other'] categories = ['developers', 'managers', 'magazines', 'other'] g = Generic('en') item = LibraryItem.query.filter_by( title=view_edit_book.title.data).first() form = BookForm(radio='book', first_name=g.person.name(), surname=g.person.surname(), title=' '.join(g.text.title().split(' ')[:3]), table_of_contents=g.text.sentence(), language=choice(languages), category=choice(categories), tag=g.text.words(1), description=g.text.sentence(), isbn=str(9789295055025), original_title=' '.join(g.text.title().split(' ')[:3]), publisher=g.business.company(), pub_date=str(randint(1970, 2018))) client.post(url_for('library.login'), data=login_form_admin_credentials.data) client.post(url_for('library_books.edit_book', item_id=item.id), data=form.data, follow_redirects=True) tmp_item = LibraryItem.query.filter_by(id=item.id).first() assert tmp_item.title == form.title.data, \ "Book title has not been updated" assert tmp_item.authors[0].first_name == form.first_name.data, \ "Authors first name has not been updated" assert tmp_item.authors[0].last_name == form.surname.data, \ "Authors last name not been updated" assert tmp_item.table_of_contents == form.table_of_contents.data, \ "Book table of contents has not been updated" assert tmp_item.language == form.language.data, \ "Book language has not been updated" assert tmp_item.category == form.category.data, \ "Book category has not been updated" assert tmp_item.description == form.description.data, \ "Book description has not been updated" assert tmp_item.isbn == form.isbn.data, \ "Book isbn has not been updated" assert tmp_item.original_title == form.original_title.data, \ "Book original_title has not been updated" assert tmp_item.publisher == form.publisher.data, \ "Book publisher has not been updated" assert tmp_item.pub_date == datetime.date( year=int(form.pub_date.data), month=1, day=1), "Book pub_date has not been updated" assert tmp_item.tags[0].name == form.tag.data[0], \ "Book tags has not been updated" session.clear()
def generate_studios(): f = open("studios.csv", 'w') gen = Generic(locales.EN) for i in range(1000): f.write( str(i + 1) + ',' + gen.text.word() + " studio" + ',' + studio_creation_date_generate() + '\n') f.close()
def _populate(amount=200): """ Add several invoices into the database for testing purpose. """ from mimesis import Generic from rs import session from datetime import datetime g = Generic("es") r = session.execute( "SELECT TOP 1 [FACTURA_ACTUAL] FROM [dbo].[POS]").first()[0] for n in range(int(r), int(r) + amount): factura = Factura( num_factura=n, cod_pos="TIENDA", tipo="F", monto_total=n, subtotal=n, monto_contado=n, monto_cheque=0, monto_tarjeta=0, monto_credito=0, monto_nc=0, monto_certificado=0, iv=0, vendedor=g.person.full_name(), cajero=g.person.full_name(), cliente=g.person.full_name(), descuento=0, cedula="114760094", # de Daniel correo=g.person.email(), ) session.add(factura) session.execute( "UPDATE [dbo].[POS] SET [FACTURA_ACTUAL] = [FACTURA_ACTUAL] + 1" ) for detalle in range(5): historico = Historico( num_factura=n, cod_pos="TIENDA", tipo="F", codigo="100001", fecha=datetime.now(), cantidad=5, precio=1000, desc_producto=g.food.dish(), proveedor="GENERAL", departamento="IT", costo=0, num_bodega=1, iv=13, ) session.add(historico) session.commit()
class BaseType(): generic = Generic(locales.EN) extra_params = ['from_column', 'to_column'] extra = False @classproperty def name(cls): return cls.__name__.removesuffix('Type') @classmethod def generate(self, count: int, extra: dict) -> iter: return ()
def create_data(generic=Generic('en'), size=10, provider=None, method=None): import inspect data = {} for c in dir(generic): if not provider or provider == c: data[c] = {} for cc in inspect.getmembers(getattr(generic, c), predicate=inspect.ismethod): if not cc[0].startswith("_"): if not method or cc[0] == method: data[c][cc[0]] = [cc[1]() for i in range(0, size)] return data
def handle(self, *args, **options): print('Deleting database!') Post.objects.all().delete() User.objects.filter(is_superuser=False).delete() Comment.objects.all().delete() Favorite.objects.all().delete() Like.objects.all().delete() person = Person() generic = Generic(locales.EN) fake = Faker() # populator = Faker.getPopulator() users = [] for fake_user in range(100): fake_user = User.objects.create_user(person.username(), person.email(), 'password') users.append(fake_user) print("100 Fake users created!") fake_posts = [] for i in range(50): post_dictionary = { 'title': fake.sentence(), 'description': fake.text(), 'user': users[random.randrange(100)], } fake_posts.append(post_dictionary) posts = [] for post_data in fake_posts: post = Post.objects.create(**post_data) posts.append(post) print('50 Posts imported!!!') for i in range(100): Like.objects.create(post=posts[random.randrange(50)], user=users[i]) print('100 Likes imported!!!') for i in range(100): Favorite.objects.create(post=posts[random.randrange(50)], user=users[i]) print('100 Favorites imported!!!') for i in range(200): Comment.objects.create(post=posts[random.randrange(50)], user=users[random.randrange(100)]) print('200 comments imported!') print('All data imported successfully!')
class BaseGenerator(object): person = Person('en') text = Text('en') generic = Generic('en') address = Address('en') data = set() def get_primary_key_data(self, num): raise NotImplementedError("Необходимо переопределить метод") def get_params(self): raise NotImplementedError("Необходимо переопределить метод") def clear_data(self): if len(self.data) != 0: self.data.clear()
def list_methods(providers=None): if providers is None: providers = list_providers() elif not isinstance(providers, list): providers = [providers] methods={} generic = Generic() for c in providers: for cc in inspect.getmembers(getattr(generic,c), predicate=inspect.ismethod): if not cc[0].startswith("_"): m=methods.setdefault(str(c),[]) m.append(str(cc[0])) return methods
def EN(count, full_errors): generic = Generic(locale='en') persons = [[ generic.person.full_name(), generic.address.city(), generic.address.street_suffix(), generic.address.street_name(), generic.address.street_number(), str(generic.numbers.between(minimum=1, maximum=100)), generic.person.telephone() ] for _ in range(count)] get_error(persons, full_errors, 'en') result = [("{}; г.{}, {} {}, {}, {}; {}".format(*p)) for p in persons] return result
def BY(count, full_errors): generic = Generic() generic.add_provider(BelarusSpecProvider) # generic.be.set_gender(Gender.FEMALE) persons = [[ generic.be.full_name(), generic.be.city_name(), generic.be.street_name(), generic.be.houses_number(), generic.be.house_apartment(), generic.be.telephone() ] for _ in range(count)] get_error(persons, full_errors, 'by') result = [("{}; г.{}, {}, {}, {}; {}".format(*p)) for p in persons] return result
def __init__(self, locate): self.g = Generic(locate) # Default global counter for sequence function self.sequences = {'global': {'current': 0, 'step': 1}} self.map = { 'address': self.g.address.address, 'city': self.g.address.city, 'latitude': self.g.address.latitude, 'longitude': self.g.address.longitude, 'postal_code': self.g.address.postal_code, 'company': self.g.business.company, 'day_of_week': self.g.datetime.day_of_week, 'timestamp': self.g.datetime.timestamp, 'dish': self.g.food.dish, 'drink': self.g.food.drink, 'fruit': self.g.food.fruit, 'vegetable': self.g.food.vegetable, 'email': self.g.person.email, 'full_name': self.g.person.full_name, 'job': self.g.person.occupation, 'phone': self.g.person.telephone, 'username': self.g.person.username, 'text': self.g.text.text, 'title': self.g.text.title, 'uuid': lambda: str(uuid.uuid4()), 'file_name': self.g.file.file_name, 'url_home': self.g.internet.home_page, 'mac': self.g.internet.mac_address, 'ip': self.g.internet.ip_v4, 'car_model': self.g.transport.car, 'imei': self.g.code.imei, 'boolean': self.g.development.boolean, 'operation_system': self.g.development.os, # Hardware 'phone_model': self.g.hardware.phone_model, 'cpu': self.g.hardware.cpu, 'cpu_codename': self.g.hardware.cpu_codename, 'cpu_frequency': self.g.hardware.cpu_frequency, 'cpu_generation': self.g.hardware.generation, 'graphics': self.g.hardware.graphics, 'manufacturer': self.g.hardware.manufacturer, 'ram_size': self.g.hardware.ram_size, 'ram_type': self.g.hardware.ram_type, 'resolution': self.g.hardware.resolution, 'screen_size': self.g.hardware.screen_size, }
def setUp(self): self.g = Generic() self.new_user = User(username=self.g.person.username(), email=self.g.person.email(), password=self.g.person.password()) self.new_user.save() self.project_title = self.g.text.title() self.description = self.g.text.text() self.website_url = self.g.internet.home_page() self.backdrop_image = self.g.person.avatar() self.new_project = Project(title=self.project_title, description=self.description, backdrop_image=self.backdrop_image, website_url=self.website_url, user=self.new_user)
def RU(count, full_errors): generic = Generic(locale='ru') generic.add_provider(RussiaSpecProvider) persons = [[ generic.person.full_name(), generic.russia_provider.patronymic(), generic.address.city(), generic.address.street_suffix(), generic.address.street_name(), generic.address.street_number(), str(generic.numbers.between(minimum=1, maximum=100)), generic.person.telephone() ] for _ in range(count)] get_error(persons, full_errors, 'ru') result = [("{} {}; г.{}, {} {}, {}, {}; {}".format(*p)) for p in persons] return result