def create_human(n):
"""
:param n: язык генерации данных
:return: сгенерированные фейковые данные
"""
log.info("Генерируем тестовые данные")
if n == 1:
person = Person('ru')
else:
person = Person('en')
log.info("person: " + str(person))
client_info = generate_id_passport()
print('\nфамилия:\t', person.last_name())
print('имя:\t\t', person.name())
print('отчество:\t', person.surname(), '\n')
passport = generate_number_passport()
print('личный №:\t', client_info.get('idn'))
print('документ:\t', passport)
print('пол:\t\t', client_info.get('sex'))
print('возраст:\t', person.age(13, 70), '\n')
# print('аватар\t', person.avatar())
print('гражд-во:\t', person.get_current_locale())
print('Нац-сть:\t',person.nationality())
print('телефон:\t', person.telephone('+37529#######'))
print('email:\t\t', person.email())
print('проф-ия:\t', person.occupation(), '\n')
print('обращение:\t', person.title())
print('взгляды:\t', person.views_on())
print('вера:\t\t', person.worldview(), '\n')
def insert_in_batches(col, total, batch_size):
many_people = []
inserted_count = 0
start_time = datetime.utcnow()
previous_time = start_time
p = Person("en", seed=0xBEE)
for i in range(total):
proxy_person = {
"name": p.first_name(),
"surname": p.surname(),
"email": p.email(),
"password": p.password()
}
many_people.append(proxy_person)
if (len(many_people) % batch_size) == 0:
col.insert_many(many_people)
inserted_count = inserted_count + len(many_people)
time_now = datetime.utcnow()
elapsed_time = time_now - previous_time
previous_time = time_now
print(f"Inserted {len(many_people)} people in {elapsed_time}")
many_people.clear()
if len(many_people) > 0:
col.insert_many(many_people)
inserted_count = inserted_count + len(many_people)
end_time = datetime.utcnow()
duration = end_time - start_time
print(f"Inserting {inserted_count} records took {duration}")
def create_human(n): # function of creating new client
if n == 1:
person = Person('ru')
else:
person = Person('en')
# Выводим исландские мужские имена.
client_info = generate_id_passport()
print('\nфамилия:\t', person.last_name())
print('имя:\t\t', person.name())
print('отчество:\t', person.surname(), '\n')
passport = generate_number_passport()
print('личный №:\t', client_info.get('idn'))
print('документ:\t', passport)
print('пол:\t\t', client_info.get('sex'))
print('возраст:\t', person.age(13, 70), '\n')
# print('аватар\t', person.avatar())
print('гражд-во:\t', person.get_current_locale())
print('Нац-сть:\t', person.nationality())
print('телефон:\t', person.telephone('+37529#######'))
print('email:\t\t', '*****@*****.**')
# print('email:\t\t', person.email())
print('проф-ия:\t', person.occupation(), '\n')
print('обращение:\t', person.title())
print('взгляды:\t', person.views_on())
print('вера:\t\t', person.worldview(), '\n')
def fill_persondata():
db = MySQLdb.connect(host=config.DB_HOST,
user=config.DB_USER,
passwd=config.DB_PASSWORD,
db=config.DB_NAME)
cursor = db.cursor()
# Zero client, anon
cursor.execute(
"""INSERT INTO PersonData (first_name, last_name, birth_date, email, mobile, gender) VALUES (%s, %s, %s, %s,
%s, %s);""", [
'anon', 'anon',
Datetime().date(start=1950, end=2001), None, None, None
])
for _ in range(config.N_PERSONS):
p = Person('ru')
cursor.execute(
"""INSERT INTO PersonData (first_name, last_name, birth_date, email, mobile, gender) VALUES (%s, %s, %s,
%s, %s, %s);""", [
p.name(),
p.surname(),
Datetime().date(start=1950, end=2001),
p.email(),
p.telephone('#' * 11),
'M' if p.gender(iso5218=True) == 1 else 'F'
])
db.commit()
cursor.close()
db.close()
def generate_people():
person = Person('en-gb')
firstname = person.first_name()
surname = person.surname()
university = person.university()
return {
"id": 0,
"firstName": firstname,
"surname": surname,
"uni": university
}
def _generate_user_data(locale='ru'):
person = Person(locale)
date = Datetime(locale)
gender = get_random_item(Gender)
return {
'password': _generate_password(),
'first_name': person.surname(gender=gender),
'last_name': person.name(gender=gender),
'email': person.email(),
'date_joined': date.datetime(start=2014, end=2015).replace(tzinfo=utc),
}
def create_personalData(): # function of generate new client data
passport = ''
person = Person('ru')
# Выводим исландские мужские имена.
lastname = person.last_name()
personalData['lastname'] = lastname
# print('\nфамилия:\t', personalData['lastname'])
name = person.name()
personalData['name'] = name
# print('имя:\t\t', personalData['name'])
surname = person.surname()
personalData['surname'] = surname
# print('отчество:\t', personalData['surname'])
gender = person.gender()
personalData['gender'] = gender
# print('пол:\t\t', personalData['gender'])
for _ in range(2):
varLet = random.choice(string.ascii_uppercase)
passport += varLet
passport += person.telephone('#######')
personalData['passport'] = passport
# print('паспорт:\t', personalData['passport'])
### birthday
currentDate()
personalData['age'] = age
personalData['age'][2] = str(
int(personalData['age'][2]) - person.age(16, 70))
# print('возраст:\t', personalData['age'], '\n')
###
# print('гражд-во:\t', person.get_current_locale())
# print('Нац-сть:\t',person.nationality())
### mobile
mobile = person.telephone('+37529#######')
personalData['mobile'] = mobile
# print('телефон:\t', personalData['mobile'])
###
### email
# personalData['email'] = person.email()
# print('email:\t\t', personalData['email'])
###
# print('проф-ия:\t', person.occupation(), '\n')
# print('обращение:\t', person.title())
# print('взгляды:\t', person.views_on())
# print('вера:\t\t', person.worldview(), '\n')
return personalData
def inf_file_unpack(path_to_file):
with open(path_to_file, 'r', encoding='UTF-8') as inf_file:
inf_file_dic = yaml.load(inf_file, Loader=yaml.FullLoader)
logger.debug(f'Распаковали inf.txt')
token = inf_file_dic['token']
logger.debug(f'Ваш токен: {token}')
country_name = inf_file_dic['country_name']
country_auto_select = inf_file_dic['country_auto_select']
logger.debug(f'Выбранная страна: {country_name}')
sex = inf_file_dic['sex']
logger.debug(f'Выбранный пол: {sex}')
person = Person('ru')
if sex == 'FEMALE':
name = person.name(gender=Gender.FEMALE)
surname = person.surname(gender=Gender.FEMALE)
else:
name = person.name(gender=Gender.MALE)
surname = person.surname(gender=Gender.MALE)
return token, country_name, name, surname, country_auto_select
def generate_users(count=1024, locale="en"):
logging.info(f"Generating {count} users.")
person = Person(locale)
for i in range(count):
user = UserModel()
user.first_name = person.name()
user.last_name = person.surname()
user.email = person.email()
user.password = person.password()
user.phone = person.telephone(mask="###.###.####")
user.save()
def create_person():
from mimesis import Person as MimesisPerson, locales, Address
person = MimesisPerson(locales.RU)
address = Address(locales.RU)
with transaction.atomic():
first_name = person.name()
last_name = person.surname()
gender = person.gender()
if gender == 'Муж.':
patronymic = choice([
'Сергеевич', 'Николаевич', 'Артурович', 'Константинович',
'Игоревич'
])
else:
patronymic = choice([
'Александровна', 'Борисовна', 'Петровна', 'Юрьевна',
'Анатольевна'
])
birth_date = generate_birthdate()
address = '{}, {}'.format(address.federal_subject(), address.address())
passport_series = randint(1000, 7000)
passport_number = randint(100000, 999999)
pair = generate_RSA_pair()
signature_public_key = pair[1]
load_key_to_file(
'../../../person_signature_private_keys/{}_{}_{}_{}.pem'.format(
passport_series, passport_number, last_name, first_name),
pair[0])
person_info = '{} {} {} {} {} {} {} {}'.format(
first_name, last_name, patronymic, birth_date, address,
passport_series, passport_number, signature_public_key)
signature_i = sign_person_info(person_info)
Person(first_name=first_name,
last_name=last_name,
patronymic=patronymic,
birth_date=birth_date,
address=address,
passport_series=passport_series,
passport_number=passport_number,
signature_public_key=signature_public_key,
signature_i=signature_i).save()
def setUp(self):
"""Generate some fake data."""
self.app = Flask('test')
util.init_app(self.app)
self.app.config['CLASSIC_DATABASE_URI'] = 'sqlite:///test.db'
self.app.config['CLASSIC_SESSION_HASH'] = 'foohash'
with self.app.app_context():
util.create_all()
with util.transaction() as session:
person = Person('en')
net = Internet('en')
ip_addr = net.ip_v4()
email = person.email()
approved = 1
deleted = 0
banned = 0
first_name = person.name()
last_name = person.surname()
suffix_name = person.title()
joined_date = util.epoch(
Datetime('en').datetime().replace(tzinfo=EASTERN))
db_user = models.DBUser(
first_name=first_name,
last_name=last_name,
suffix_name=suffix_name,
share_first_name=1,
share_last_name=1,
email=email,
flag_approved=approved,
flag_deleted=deleted,
flag_banned=banned,
flag_edit_users=0,
flag_edit_system=0,
flag_email_verified=1,
share_email=8,
email_bouncing=0,
policy_class=2, # Public user. TODO: consider admin.
joined_date=joined_date,
joined_ip_num=ip_addr,
joined_remote_host=ip_addr)
session.add(db_user)
self.user = domain.User(user_id=str(db_user.user_id),
username='******',
email=db_user.email,
name=domain.UserFullName(
forename=db_user.first_name,
surname=db_user.last_name,
suffix=db_user.suffix_name))
def make_full_name(self, loc, value):
global sex
per = Person(loc)
rsp = RussiaSpecProvider()
if value == 'male':
sex = Gender.MALE
elif value == 'famale':
sex = Gender.FEMALE
name = per.name(sex)
surname = per.surname(sex)
patron = rsp.patronymic(sex)
age = per.age(16, 66)
occup = per.occupation()
return name, surname, patron, age, occup
def insert_one_at_a_time(col, total):
start_time = datetime.utcnow()
p = Person("en", seed=0xBEE)
for i in range(total): # 0..total-1
proxy_person = {
"name": p.first_name(),
"surname": p.surname(),
"email": p.email(),
"password": p.password()
}
col.insert_one(proxy_person)
if ((i + 1) % 10) == 0:
print(f"Inserted {i+1} docs")
end_time = datetime.utcnow()
duration = end_time - start_time
print(f"Inserting {i + 1} records took {duration}")
def _bootstrap(count):
from mimesis import Person
person = Person("en")
for _ in range(count):
u = User(
email=person.email(),
confirmed=True,
first_name=person.name(),
last_name=person.surname(),
)
db.session.add(u)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
def _generate_questionnaire_data(locale='ru') -> dict:
person = Person(locale)
rus_spec = RussiaSpecProvider()
datetime = Datetime(locale)
g = get_random_item(Gender)
created = datetime.datetime(start=2015, end=2018)
return {
'id': uuid.uuid4(),
'created': created.replace(tzinfo=utc),
'updated': created.replace(tzinfo=utc),
'surname': person.surname(gender=g),
'first_name': person.name(gender=g),
'patronymic': rus_spec.patronymic(gender=g),
'birth_date': datetime.datetime(start=1960, end=1998).date(),
'phone_num': person.telephone(),
'pass_ser': rus_spec.passport_series(),
'pass_num': rus_spec.passport_number(),
'score': randint(0, 2000),
}
def generate():
inserts = []
counter = 330
person = Person('en')
business = Business('en')
address = Address('en')
internet = Internet('en')
for index in range(counter, 15000, 1):
inserts.append(template.substitute(id=index,
name=person.name().replace("'", "''"),
surname=person.surname().replace("'", "''"),
email=person.email().replace("'", "''"),
phone=person.telephone(),
customer_id=random.randint(330, 14999)
))
inserts_file = open('result_scripts/contacts.sql', 'w', encoding='utf-8')
inserts_file.writelines('\n'.join(inserts))
inserts_file.close()
def users(count: int = 500) -> List[models.User]:
"""Generate a bunch of random users."""
_users = []
for i in range(count):
locale = _get_locale()
person = Person(locale)
net = Internet(locale)
ip_addr = net.ip_v4()
_users.append(
models.User(
first_name=person.name(),
last_name=person.surname(),
suffix_name=person.title(),
share_first_name=1,
share_last_name=1,
email=person.email(),
share_email=8,
email_bouncing=0,
policy_class=2, # Public user.
joined_date=_epoch(Datetime(locale).datetime()),
joined_ip_num=ip_addr,
joined_remote_host=ip_addr))
return _users
##################################################
##################################################
### Generate a DataFrame of user information
##################################################
# Generate 10,000 rows of the following:
# user_id, first_name, last_name, email, password, address,
# birth_date, credit_card_num, credit_card_exp, security_answer,
# account_balance
user_df = pd.DataFrame([[
x,
person.name(),
person.surname(),
person.gender(),
person.email(),
hashed_passwd(person.password()),
address.address(),
person.age(),
payment.credit_card_number(),
payment.credit_card_expiration_date(),
text.word(),
account_balance(),
np.random.randint(1, 11)
] for x in range(10000)])
user_df.columns = [
"user_id", "first_name", "last_name", "gender", "email", "password_hashed",
"address", "age", "credit_card_num", "credit_card_exp", "security_answer",
def setUp(self):
"""Generate some fake data."""
self.app = Flask('test')
util.init_app(self.app)
self.app.config['CLASSIC_DATABASE_URI'] = 'sqlite:///test.db'
self.app.config['CLASSIC_SESSION_HASH'] = 'foohash'
with self.app.app_context():
util.create_all()
with util.transaction() as session:
person = Person('en')
net = Internet('en')
ip_addr = net.ip_v4()
email = "*****@*****.**"
approved = 1
deleted = 0
banned = 0
first_name = person.name()
last_name = person.surname()
suffix_name = person.title()
joined_date = util.epoch(
Datetime('en').datetime().replace(tzinfo=EASTERN))
db_user = models.DBUser(
first_name=first_name,
last_name=last_name,
suffix_name=suffix_name,
share_first_name=1,
share_last_name=1,
email=email,
flag_approved=approved,
flag_deleted=deleted,
flag_banned=banned,
flag_edit_users=0,
flag_edit_system=0,
flag_email_verified=1,
share_email=8,
email_bouncing=0,
policy_class=2, # Public user. TODO: consider admin.
joined_date=joined_date,
joined_ip_num=ip_addr,
joined_remote_host=ip_addr)
session.add(db_user)
self.user = domain.User(user_id=str(db_user.user_id),
username='******',
email=db_user.email,
name=domain.UserFullName(
forename=db_user.first_name,
surname=db_user.last_name,
suffix=db_user.suffix_name))
ok_patterns = ['%w3.org', '%aaas.org', '%agu.org', '%ams.org']
bad_patterns = ['%.com', '%.net', '%.biz.%']
with util.transaction() as session:
for pattern in ok_patterns:
session.add(models.DBEmailWhitelist(pattern=str(pattern)))
for pattern in bad_patterns:
session.add(models.DBEmailBlacklist(pattern=str(pattern)))
session.add(
models.DBEndorsementDomain(
endorsement_domain='test_domain',
endorse_all='n',
mods_endorse_all='n',
endorse_email='y',
papers_to_endorse=3))
for category, definition in taxonomy.CATEGORIES_ACTIVE.items():
if '.' in category:
archive, subject_class = category.split('.', 1)
else:
archive, subject_class = category, ''
session.add(
models.DBCategory(archive=archive,
subject_class=subject_class,
definitive=1,
active=1,
endorsement_domain='test_domain'))
def setUpClass(cls):
"""Generate some fake data."""
cls.app = Flask('test')
util.init_app(cls.app)
cls.app.config['CLASSIC_DATABASE_URI'] = 'sqlite:///test.db'
cls.app.config['CLASSIC_SESSION_HASH'] = 'foohash'
cls.app.config['CLASSIC_SESSION_TIMEOUT'] = '36000'
with cls.app.app_context():
util.create_all()
COUNT = 50
cls.users = []
_users = []
_domain_users = []
for i in range(COUNT):
with util.transaction() as session:
locale = _get_locale()
person = Person(locale)
net = Internet(locale)
ip_addr = net.ip_v4()
email = person.email()
approved = 1 if _prob(90) else 0
deleted = 1 if _prob(2) else 0
banned = 1 if random.randint(0, 100) <= 1 else 0
first_name = person.name()
last_name = person.surname()
suffix_name = person.title()
name = (first_name, last_name, suffix_name)
joined_date = util.epoch(
Datetime(locale).datetime().replace(tzinfo=EASTERN))
db_user = models.DBUser(
first_name=first_name,
last_name=last_name,
suffix_name=suffix_name,
share_first_name=1,
share_last_name=1,
email=email,
flag_approved=approved,
flag_deleted=deleted,
flag_banned=banned,
flag_edit_users=0,
flag_edit_system=0,
flag_email_verified=1,
share_email=8,
email_bouncing=0,
policy_class=2, # Public user. TODO: consider admin.
joined_date=joined_date,
joined_ip_num=ip_addr,
joined_remote_host=ip_addr)
session.add(db_user)
# Create a username.
username_is_valid = 1 if _prob(90) else 0
username = person.username()
db_nick = models.DBUserNickname(
user=db_user,
nickname=username,
flag_valid=username_is_valid,
flag_primary=1)
# Create the user's profile.
archive, subject_class = _random_category()
db_profile = models.DBProfile(
user=db_user,
country=locale,
affiliation=person.university(),
url=net.home_page(),
rank=random.randint(1, 5),
archive=archive,
subject_class=subject_class,
original_subject_classes='',
flag_group_math=1 if _prob(5) else 0,
flag_group_cs=1 if _prob(5) else 0,
flag_group_nlin=1 if _prob(5) else 0,
flag_group_q_bio=1 if _prob(5) else 0,
flag_group_q_fin=1 if _prob(5) else 0,
flag_group_stat=1 if _prob(5) else 0)
# Set the user's password.
password = person.password()
db_password = models.DBUserPassword(
user=db_user,
password_storage=2,
password_enc=util.hash_password(password))
# Create some endorsements.
archive, subject_class = _random_category()
net_points = 0
for _ in range(0, random.randint(1, 4)):
etype = random.choice(['auto', 'user', 'admin'])
point_value = random.randint(-10, 10)
net_points += point_value
if len(_users) > 0 and etype == 'auto':
endorser_id = random.choice(_users).user_id
else:
endorser_id = None
issued_when = util.epoch(
Datetime(locale).datetime().replace(
tzinfo=EASTERN))
session.add(
models.DBEndorsement(endorsee=db_user,
endorser_id=endorser_id,
archive=archive,
subject_class=subject_class,
flag_valid=1,
endorsement_type=etype,
point_value=point_value,
issued_when=issued_when))
session.add(db_password)
session.add(db_nick)
session.add(db_profile)
_users.append(db_user)
_domain_users.append(
(domain.User(user_id=str(db_user.user_id),
username=db_nick.nickname,
email=db_user.email,
name=domain.UserFullName(
forename=db_user.first_name,
surname=db_user.last_name,
suffix=db_user.suffix_name),
verified=bool(
db_user.flag_email_verified)),
domain.Authorizations(
classic=util.compute_capabilities(db_user), )))
session.commit()
# We'll use these data to run tests.
cls.users.append((
email,
username,
password,
name,
(archive, subject_class, net_points),
(approved, deleted, banned),
))
from mimesis import Person
# Connection object
c = pymongo.MongoClient(
host="mongodb+srv://livedemo:[email protected]/test_db?retryWrites=true&w=majority")
# database object
database = c["test_db"]
# collection/table object
collection = database["users"]
p = Person("en", seed=0xBEEF)
person = {"name": p.first_name(),
"surname": p.surname(),
"email": p.email(),
"password": p.password()}
collection.insert_one(person)
print("Inserted:")
pprint.pprint(person)
collection.update_one({"_id": person["_id"]}, {"$set": {"session_id": 20}})
collection.update_one({"_id": person["_id"]}, {"$push": {"phone": {"cell": "+1 123456789"}}})
doc = collection.find_one({"_id": person["_id"]})
print("Updated:")
pprint.pprint(doc)
collection.update_many({"surname": "Taylor"}, {"$push": {"assets": {"laptop": "MacPro laptop"}}})
laptop_count = collection.count_documents({"surname": "Taylor", "assets.laptop": "MacPro laptop"})
noise = noise_ampl*np.random.normal(0.01, 1.7, df.shape[0])
gated_age = np.heaviside(df[age] - min_age, 0.5) - np.heaviside(df[age] - max_age, 0.5)
return 0.01*pow(np.abs(df[age] - 30), 2.5) + df[age] + 50*df[marketing_level]*gated_age + 2*df[account_balance] + noise
##################################################
##################################################
### Generate a DataFrame of user information
##################################################
# Generate 10,000 rows of the following:
# user_id, first_name, last_name, email, password, address,
# birth_date, credit_card_num, credit_card_exp, security_answer,
# account_balance
user_df = pd.DataFrame([[x, person.name(), person.surname(), person.gender(),
person.email(), hashed_passwd(person.password()),
address.address(), person.age(),
payment.credit_card_number(),
payment.credit_card_expiration_date(), text.word(),
account_balance(), np.random.randint(1, 11)]
for x in range(10000)])
user_df.columns = ["user_id", "first_name", "last_name",
"gender", "email", "password_hashed", "address",
"age", "credit_card_num", "credit_card_exp",
"security_answer", "account_balance",
"marketing_level"]
# Generate sales, based on a noisy linear model
user_df['sales'] = generate_sales(user_df)
from mimesis import Person
import random
person = Person('uk')
name = person.name()
email = person.email()
surname = person.surname()
phone = int("63" + str(random.randint(1000000, 9999999)))
print(name)
print(surname)
print(phone)
print(person)
print(email)
