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
