def test():
"""测试新建Provider.
"""
fake = Faker()
fake.add_provider(ChinaProvider)
for _ in range(10):
print(fake.cn_email())
print(fake.cn_tag())
def setUp(self):
self.client = Client()
Faker.seed(42)
faker = Faker('ru_RU')
faker.add_provider(CategoryShortName)
self.name = faker.name()
self.email = faker.email()
self.message = faker.text()
self.user = CoreUser.objects.create_user(username=faker.name(),
email=faker.email(),
is_manager=faker.boolean())
self.category = mixer.blend(Category, user=self.user)
self.product = mixer.blend(Product, user=self.user)
def fill_candidates_info(candidates_info, con):
for _ in range(N):
fake = Faker()
fake.add_provider(profile)
data = fake.profile(fields=None, sex=None)
gender = data.get('sex')
current_gender = 0
if gender == 'M':
current_gender = 1
clause = candidates_info.insert().values(nationality='russian', gender=current_gender, age=20,
email=data.get('mail'))
con.execute(clause)
class CoreTest(TestCase):
def setUp(self):
self.fake = Faker()
self.fake.add_provider(Provider)
def tearDown(self):
pass
def create_app(self):
return create_app(CONFIG)
def test_faker_example(self):
self.assertEqual(self.fake.foo(), 'bar')
def __init__(self):
config = configparser.ConfigParser()
cwd = os.path.abspath(automated_bot.__path__[0])
file_path = os.path.join(cwd, 'settings.ini')
config.read(file_path)
self._config = config
fake = Faker()
fake.add_provider(internet)
self._fake = fake
self._email_hunter_client = EmailHunterClient(
config.get('bot', 'EMAIL_HUNTER_KEY'))
def load_initial_data():
fake = Faker('ru_RU')
fake.add_provider(lorem)
fake.add_provider(company)
for i in range(3):
name = fake.word()
price = fake.pyint()
description = fake.text(max_nb_chars=300, ext_word_list=None)
image_file = f"image_{i}.jpg"
item = ItemModel(name, price, description, image_file)
item.save_to_db()
print(item)
def main():
# How to create your own provider
# Note you cannot have multiple locales!!!!
fake = Faker(['en_UK'])
# Add your provider - note the construction of a non instance
fake.add_provider(HairColourProvider(fake))
# Use it!
colour = fake.hair_colour(Gender.MALE)
print(colour)
print(colour.name.title())
colour = fake.hair_colour(Gender.FEMALE)
print(colour)
print(colour.name.title())
def test_with_dynamic(self):
faker = Faker()
elements = ["dr.", "doctor", "nurse", "surgeon", "clerk"]
provider_name = "medical_profession"
medical_professions_provider = DynamicProvider(
provider_name=provider_name,
elements=elements,
)
faker.add_provider(medical_professions_provider)
assert faker.medical_profession() in elements
def test_e164(self):
"""Test generating e164 phone numbers for all regions"""
fake = Faker() # type: Union[E164Provider, Faker]
fake.add_provider(self.provider_class)
for region_code in phonenumbers.SUPPORTED_REGIONS:
phone_number = fake.e164(region_code=region_code)
self.assertIsInstance(phone_number, str)
phone_number = phonenumbers.parse(phone_number)
self.assertTrue(phonenumbers.is_valid_number(phone_number))
phone_number = fake.e164()
self.assertIsInstance(phone_number, str)
phone_number = phonenumbers.parse(phone_number)
self.assertTrue(phonenumbers.is_valid_number(phone_number))
def test_register_user(self):
fake = Faker()
fake.add_provider(ProfileProvider)
token_adm = get_new_token('REG_ADM')
fake_user = fake.moevm_profile()
fake_user['login'] = fake.user_name()
fake_user['password'] = fake.password()
fake_user['token'] = token_adm
fake_user['type'] = 'Администратор'
user = register_user(fake_user)
self.assertIsNotNone(user)
self.assertIsNone(check_token(token_adm, 'REG_ADM'))
delete_user(user.id)
class FakerTemplateLibrary:
"""A Jinja template library to add the faker.xyz objects to templates"""
def __init__(self, faker_providers: Sequence[object], locale=None):
self.locale = locale
self.faker = Faker(self.locale)
for provider in faker_providers:
self.faker.add_provider(provider)
def __getattr__(self, name):
return StringGenerator(
lambda *args, **kwargs: self.faker.format(name, *args, **kwargs)
)
def main():
"""Runs the provider. The test file has more specific cases."""
fake = Faker(['en_UK'])
fake.add_provider(NationalityProvider)
number = fake.nationality(
NationalityProvider.countries_by_iso2['GB']['country_or_area'],
date(1960, 10, 10))
print(number)
number = fake.nationality(
NationalityProvider.countries_by_iso2['IN']['country_or_area'],
date(1960, 10, 10))
print(number)
class TestCarProvider(unittest.TestCase):
def setUp(self):
self.fake = Faker('')
Faker.seed(0)
self.fake.add_provider(CarProvider)
def test_car2(self):
print()
print(self.fake.car())
print(self.fake.car_model())
def test_car(self):
assert self.fake.car()
assert self.fake.car_model()
def handle(self, *args, **options):
fake = Faker('pl_PL')
fake.add_provider(internet)
fake.add_provider(misc)
for _ in range(DEFAULT_USER_NUM):
user = User.objects.create_user(username=fake.name(),
email=fake.email(),
password=fake.password())
for _ in range(DEFAULT_TWEET_PER_USER):
tweet = models.Tweet(
author=user,
content=fake.text(max_nb_chars=models.TWITER_MAX_LENGTH))
tweet.save()
class TestWifiESSID(unittest.TestCase):
"""
Unit tests for the 'WifiESSID' class.
"""
def setUp(self):
self.fake = Faker()
self.fake.add_provider(WifiESSID)
def test_if_string(self):
"""
Tests if the values returned by the fake Wi-Fi ESSID
generators are strings.
"""
for _ in range(10):
self.assertTrue(isinstance(self.fake.common_essid(), str))
self.assertTrue(isinstance(self.fake.upc_default_essid(), str))
self.assertTrue(isinstance(self.fake.bbox_default_essid(), str))
self.assertTrue(isinstance(self.fake.wifi_essid(), str))
def test_common_essid(self):
"""
Tests if the 'common_essid()' method returns values from
'COMMON_ESSIDS' as expected.
"""
for _ in range(10):
self.assertTrue(self.fake.common_essid() in COMMON_ESSIDS)
def test_upc_default_essid(self):
"""
Tests if the values returned by the 'upc_default_essid()' method match
the UPC ESSIDs' regex.
"""
regex = re.compile(r"^UPC\d{7}$")
for _ in range(10):
self.assertTrue(re.match(regex, self.fake.upc_default_essid()))
def test_bbox_default_essid(self):
"""
Tests if the values returned by the 'bbox_default_essid()' method match
the Bbox ESSIDs' regex.
"""
regex = re.compile(r"^Bbox-[A-F0-9]{6}$")
for _ in range(10):
self.assertTrue(re.match(regex, self.fake.bbox_default_essid()))
def test_dynamic_add_element(self):
elements = []
provider_name = "my_provider"
provider = DynamicProvider(
provider_name=provider_name,
elements=elements,
)
faker = Faker()
faker.add_provider(provider)
provider.add_element("one")
provider.add_element("two")
assert faker.my_provider() in ("one", "two")
class RealNamor(Namor):
def __init__(self):
self.faker = TruFaker()
self.faker.add_provider(person)
def generate_name(self, sex: str) -> Tuple[str, str]:
if sex == 'F':
return (self.faker.first_name_female(),
self.faker.last_name_female())
if sex == 'M':
return (self.faker.first_name_male(), self.faker.last_name_male())
return (self.faker.first_name(), self.faker.last_name())
def main():
fake = Faker()
fake.add_provider(Provider)
#with open('data.txt', 'r+') as outfile:
for i in range(10):
basic_profile = fake.simple_profile()
basic_profile = fake.basics(basic_profile)
profile = fake.build_profile(basic_profile, fake.gender(),
fake.gender_preference(),
fake.age(basic_profile['age_group']),
fake.kids(), fake.drugs())
print(profile)
def get_current_weather_response(self):
faker = Faker()
faker.add_provider(WeatherFakerProvider)
return {
"weather": [{
"main": faker.get_weather_text(),
"icon": faker.get_openweathermap_icon()
}],
"main": {
"temp": faker.get_temperature(),
},
"dt":
faker.get_epoch_time(),
}
class TestSequenceFaker(unittest.TestCase):
def setUp(self):
random.seed(0)
self.fake = Faker()
self.fake.add_provider(SequenceFaker)
def test_sequence_type_range_adherence(self):
for sequence_type in SequenceFaker.SEQUENCE_TYPES:
actual = self.fake.sequence(sequence_type=sequence_type,
min=10,
max=50,
count=1)[0]
self.assertLessEqual(actual, 50)
self.assertGreaterEqual(actual, 10)
def test_sequence_type_count(self):
for sequence_type in SequenceFaker.SEQUENCE_TYPES:
actual = self.fake.sequence(sequence_type=sequence_type, count=20)
self.assertEqual(len(actual), 20)
def test_rounding(self):
for sequence_type in SequenceFaker.SEQUENCE_TYPES:
actual = self.fake.sequence(sequence_type=sequence_type,
count=1,
should_round=True,
ndigits=None)[0]
self.assertTrue(isinstance(actual, int))
actual = self.fake.sequence(sequence_type=sequence_type,
count=1,
should_round=True,
ndigits=2)[0]
self.assertEqual(round(actual, 2), actual)
def test_hardcoded_sequences(self):
expected_sequences = {
"UNIFORM": [7, 5, -2, -5, 0, -2, 6, -4, 0, 2],
"SINUSOIDAL": [0, 0, 3, -2, -1, -1, 2, 1, 4, -2],
"PERLIN": [0, -1, 0, 2, 1, 7, 0, -8, -2, 0],
}
for sequence_type in SequenceFaker.SEQUENCE_TYPES:
actual = self.fake.sequence(
sequence_type=sequence_type,
should_round=True,
ndigits=None,
min=-10,
max=10,
)
self.assertCountEqual(actual, expected_sequences[sequence_type])
def generate():
fake = Faker()
fake.add_provider(lorem)
fake.add_provider(python)
fake.add_provider(date_time)
fake.add_provider(bank)
for _ in range(5):
time = datetime.datetime.strptime(
fake.time(pattern='%H:%M', end_datetime=None), "%H:%M").time()
print(type(time))
new_auction = Auction(name=fake.name(),
category=fake.name(),
country=fake.bank_country(),
min_price=fake.pydecimal(left_digits=None,
right_digits=2,
positive=True,
min_value=1,
max_value=None),
auction_image='default_image.jpg',
end_day=fake.date_this_year(before_today=False,
after_today=True),
end_time=time,
description=fake.paragraphs(nb=3,
ext_word_list=None),
user_id=current_user.id)
db.session.add(new_auction)
db.session.commit()
return render_template('index.html')
def main():
# How to create your own provider
# Note you cannot have multiple locales!!!!
fake = Faker(['en_UK'])
# Add your provider
fake.add_provider(BuildProvider)
# Use it!
build = fake.build(18.4, 163, Gender.FEMALE)
print(build)
# Use it!
build = fake.build(20, 163, Gender.MALE)
print(build)
class MilMoveData:
"""Base class to return fake data to use in MilMove endpoints."""
def __init__(self):
"""
Sets up a Faker attribute and a dict of handled data types for this instance.
"""
self.fake = Faker()
self.fake.add_provider(MilMoveProvider)
self.data_types = {
DataType.FIRST_NAME: self.fake.safe_first_name,
DataType.FIRST_NAME_VARIANT: self.fake.safe_first_name,
DataType.MIDDLE_NAME: self.fake.safe_middle_name,
DataType.MIDDLE_NAME_VARIANT: self.fake.safe_middle_name,
DataType.LAST_NAME: self.fake.safe_last_name,
DataType.LAST_NAME_VARIANT: self.fake.safe_last_name,
DataType.SUFFIX: self.fake.suffix,
DataType.PHONE: self.fake.safe_phone_number,
DataType.EMAIL: self.fake.safe_email,
DataType.STREET_ADDRESS: self.fake.safe_street_address,
DataType.CITY: self.fake.city,
DataType.STATE: self.fake.state_abbr,
DataType.POSTAL_CODE: self.fake.safe_postal_code,
DataType.POSTAL_CODE_VARIANT: self.fake.safe_postal_code,
DataType.COUNTRY: self.fake.safe_country,
DataType.CITY_STATE_ZIP: self.fake.safe_city_state_zip,
DataType.DATE: self.fake.date_between,
DataType.DATE_TIME: self.fake.iso_date_time,
DataType.TIME_MILITARY: self.fake.time_military,
DataType.SENTENCE: self.fake.sentence,
DataType.BOOLEAN: self.fake.boolean,
DataType.INTEGER: self.fake.random_int,
DataType.UUID: self.fake.safe_uuid,
DataType.TAC: self.fake.tac,
}
def get_random_choice(self, choices):
"""Given a list of random choices, returns one of them."""
return self.fake.random_element(choices)
def get_fake_data_for_type(self, data_type, params=None):
"""Given a specific data type, returns faker data for that type (if a mapping exists)."""
if not params:
params = []
try:
return self.data_types[data_type](*params)
except KeyError: # data_type isn't in dictionary
logger.exception(f"An unexpected data type was passed into get_fake_data_for_type: {data_type}")
return None
def generated():
l0g("----------------------------------------> INFORMATIONS <-------------------------------------- ")
print()
print("GENERATING INFORMATION : ",flush=True,end="")
try:
fake = Faker('en_US')
fake.add_provider(E164Provider)
nna=fake.name()
first_name=fake.first_name()
last_name=fake.last_name()
phon_number =fake.e164(region_code="US", valid=True, possible=True)
company_name=fake.bs()
#street_address=fake.street_address()
address_=fake.address()
tt=address_.split(",")
street_address=tt[0].replace("\n"," ")
street_address=street_address
a_address_= address_.split()
zip_code=a_address_[-1]
city_0=tt[0].split("\n")
city_1=city_0[1]
city_=""
add=city_1
for i in add.split() :
if i.isalpha() :
city_+=i+" "
street0_=city_0[0]
dom=random.randint(1,len(domains))
#timestamp = datetime.datetime.now()
timestamp =time.strftime("%H%M%S", time.gmtime())
vary=password0(4,4)
t = str(timestamp)+vary
email_ja=nna.replace(" ",t)
#[email protected]
#email_do="ezk0000za+"+email_ja+domains[dom-1]
email_do=email_ja+domains[dom-1]
email_do=email_do.lower()
if ".@" in email_do:
email_do=email_do.replace(".@","@")
print ("DONNE")
print("SESSION INFORMATIONS OF : ",flush=True,end="")
print("[ "+email_do+" ]\n")
return first_name,last_name,phon_number,company_name,email_do ,street_address,zip_code,city_,street0_
except Exception as e:
print(str(e))
#input()
generated()
class TestFetch( unittest.TestCase ):
def setUp( self ):
self.fake = Faker()
self.fake.add_provider( FakeModel )
self.server = FetchServer( ('127.0.0.1', 58765), FetchHandler )
self.server.data = []
self.server_thread = threading.Thread( target=self.server.serve_forever )
self.server_thread.daemon = True
self.server_thread.start()
return super( TestFetch, self ).setUp()
def tearDown( self ):
self.server.shutdown()
self.server.server_close()
return super( TestFetch, self ).tearDown()
def test_fetch_location_list( self ):
schema = self.fake.schema()
timestamp_key = [c['name'] for c in schema if 'timestamp' in c][0]
fake_data = []
for i in range( 1000 ):
row = self.fake.row( schema )
row[timestamp_key] = random.randint( 11140000, 19950000 )
fake_data.append( row )
self.server.data = fake_data
fetcher = Fetcher()
idx = 0
for fetched in fetcher.fetch_location( 'http://127.0.0.1:58765/fake.json', '1' ):
fake_data[idx]['location'] = '1'
self.assertDictEqual( fetched, fake_data[idx] )
idx += 1
def test_fetch_location( self ):
schema = self.fake.schema()
timestamp_key = [c['name'] for c in schema if 'timestamp' in c][0]
fake_row = self.fake.row( schema )
fake_row[timestamp_key] = random.randint( 11140000, 19950000 )
self.server.data = fake_row
fetcher = Fetcher()
for fetched in fetcher.fetch_location( 'http://127.0.0.1:58765/fake.json', '1' ):
fake_row['location'] = '1'
self.assertDictEqual( fetched, fake_row )
def fakertest(n=10):
print('Testing Faker')
# Uses python random module
# https://docs.python.org/3.6/library/random.html
fake = Faker()
fake.add_provider(NormalProvider)
#print(fake.smplnorm())
#return
schema = {'var1': [], 'var2': [], 'var3': []}
# instance of the random number generator
rndm = fake.random
y_max = norm.pdf(0., 0., 0.1)
def faker_sampler():
x = rndm.uniform(-1, 1)
y = rndm.uniform(0, y_max)
yp = norm.pdf(x, 0., 0.1)
if (y < yp):
return x
else:
return None
# returns object of current state
# rndm.getstate()
#print(fake.address())
for _ in range(n):
schema['var1'].append(fake.smplnorm())
schema['var2'].append(fake.name())
schema['var3'].append(fake.ssn())
#i=0
#while(i<n):
#g = faker_sampler()
#if g:
#print(g)
#print(fake.name())
#print(fake.ssn())
#g = float("{0:.2f}".format(x))
#schema['var1'].append(g)
#schema['var1'].append(float("{0:.2f}".format(g)))
#schema['var1'].append(fake.smplnorm())
#schema['var2'].append(fake.name())
#schema['var3'].append(fake.ssn())
#i += 1
# Create the df from dictionary
df = pd.DataFrame(schema)
print(df)
plt.figure()
df['var1'].plot.hist()
def init_data(apps, schema_editor):
fake = Faker()
fake.add_provider(profile)
users_set = set()
email_set = set()
users = []
User = apps.get_model('core', 'User')
while len(users_set) < 10:
user = fake.profile(fields=['username', 'mail'])
if (user['username'] not in users_set) and (user['mail']
not in email_set):
users_set.add(user['username'])
email_set.add(user['mail'])
users.append(User(username=user['username'], email=user['mail']))
User.objects.bulk_create(users)
def example_use():
fake = Faker()
fake.add_provider(MyProvider)
# load data to dict
raw_data = open("sample_data.yaml").read()
pydict_data = yaml.load(raw_data)
print("Original data:")
print_dict(pydict_data)
# render data
for key, value in pydict_data.items():
pydict_data[key] = fake.render_template(value)
print("Data after process:")
print_dict(pydict_data)
def fake():
_fake = Faker()
_fake.add_provider(human.HumanProvider)
_fake.add_provider(alien.AlienProvider)
_fake.add_provider(binary.BinaryProvider)
_fake.add_provider(chemistry.ChemistryProvider)
_fake.add_provider(biology.GeneticProvider)
return _fake
def forge(count):
""" fake data to database """
db.create_all()
fake = Faker('zh_CN')
fake.add_provider(lorem)
title_list = fake.sentences(nb=100)
for i in range(0, count):
article = Article(title=title_list[i],
content=fake.text(3000),
time=datetime.datetime.now())
db.session.add(article)
click.echo("created %d articles" % count)
db.session.commit()
click.echo(".Done")
pass
def main():
fake = Faker(['en_UK'])
fake.add_provider(MilitaryRankProvider(fake))
rank = fake.military_rank(MilitaryService.ROYAL_NAVY)
print(MilitaryService.ROYAL_NAVY, rank)
rank = fake.military_rank(MilitaryService.ROYAL_MARINES)
print(MilitaryService.ROYAL_MARINES, rank)
rank = fake.military_rank(MilitaryService.BRITISH_ARMY)
print(MilitaryService.BRITISH_ARMY, rank)
rank = fake.military_rank(MilitaryService.ROYAL_AIR_FORCE)
print(MilitaryService.ROYAL_AIR_FORCE, rank)
def post(self, request, *args, **kwargs):
n = request.POST.get('num')
if n.isnumeric():
fake = Faker()
fake.add_provider(internet)
objs = RouterDetail.objects.bulk_create([
RouterDetail(sap_id=random.choice(['AGI1', "CSS"]),
loopback=fake.ipv4_private(),
internet_host_names=fake.hostname(),
mac_address=fake.mac_address())
for _ in range(int(n))
])
return redirect('/')
def FakerCinema():
fake = Faker()
fake.add_provider(ExhibitorProvider)
fake.add_provider(CinemaProvider)
fake.add_provider(ScreenProvider)
fake.add_provider(CPLProvider)
return fake
import demistomock as demisto
from CommonServerPython import *
from CommonServerUserPython import *
'''IMPORTS'''
from faker import Faker
from faker.providers import internet, misc, lorem, user_agent
from datetime import datetime
import json
import random
import math
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
'''SETUP'''
fake = Faker()
fake.add_provider(internet)
fake.add_provider(misc)
fake.add_provider(lorem)
fake.add_provider(user_agent)
'''GLOBAL VARS'''
PARAMS = demisto.params()
INCIDENT_TYPE = PARAMS.get('incidentType', 'PhishingDemo')
INCIDENTS_PER_MINUTE = int(PARAMS.get('incidents_per_minute', '5'))
MAX_NUM_OF_INCIDENTS = int(PARAMS.get('max_num_of_incidents', '10'))
FREQUENCY = PARAMS.get('frequency')
INDICATORS_PER_INCIDENT = 5
INDICATORS_TO_INCLUDE = ['ipv4_public', 'url', 'domain_name', 'sha1', 'sha256', 'md5']
EMAIL_PROTOCOLS = ['POP3', 'IMAP', 'SMTP', 'ESMTP', 'HTTP', 'HTTPS']
# About the drop some mean regex right now disable-secrets-detection-start
TEMPLATE_1 = '''<!doctype html>
from uuid import uuid4
import factory
from factory.fuzzy import FuzzyChoice
from factory.mongoengine import MongoEngineFactory
from faker import Faker
from udata import models
from udata.core.discussions.models import Message
from .geojson_provider import GeoJsonProvider
faker = Faker()
faker.add_provider(GeoJsonProvider)
def unique_string(length=None):
'''Generate unique string'''
string = str(uuid4())
return string[:length] if length else string
class SiteSettingsFactory(MongoEngineFactory):
class Meta:
model = models.SiteSettings
class SiteFactory(MongoEngineFactory):
class Meta:
from edc_identifier.subject.classes.subject_identifier import SubjectIdentifier
from edc_constants.constants import YES, NO, NOT_APPLICABLE
# from edc_call_manager.caller_site import site_model_callers
from bcpp_interview.models import PotentialSubject, CATEGORIES, SUB_CATEGORIES, INITIATED, SubjectLocator
fake = Faker()
# site_model_callers.autodiscover()
class BwCellProvider(BaseProvider):
def cellphonebw(self):
return '7' + str(random.randint(1000000, 9999999))
fake.add_provider(BwCellProvider)
COMMUNITIES = (
('Bokaa', 'Bokaa'),
('Digawana', 'Digawana'),
('Gumare', 'Gumare'),
('Gweta', 'Gweta'),
('Lentsweletau', 'Lentsweletau'),
('Lerala', 'Lerala'),
('Letlhakeng', 'Letlhakeng'),
('Mandunyane', 'Mandunyane'),
('Mmankgodi', 'Mmankgodi'),
('Mmadinare', 'Mmadinare'),
('Mmathethe', 'Mmathethe'),
('Masunga', 'Masunga'),
]
self.__perks = [
'first 60 mi free',
'50% discount after 120 mi',
'1 day free after 3 days',
'hotel 50% off after a week'
]
def service_type(self):
return fake.random_element(self.__types)
def service_perks(self):
return fake.random_element(self.__perks)
class TripsProvider(BaseProvider):
def __init__(self, other):
super().__init__(other)
self.__highlights = [
'I can kiss you as much you want.',
'Trip Highligh 2',
'Trip Highligh 3'
]
def trip_highligh(self):
return fake.random_element(self.__highlights)
# then add new provider to faker instance
fake.add_provider(CarsProvider)
fake.add_provider(ServicesProvider)
fake.add_provider(TripsProvider)
class Command(BaseCommand):
help = 'Add fake data to the database.'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.faker = Faker()
self.faker.add_provider(UniqueUrlProvider)
def add_arguments(self, parser):
parser.add_argument(
'--seed', action='store', default=None,
help='Provide an initial seed for randomization mechanism.',
)
def fake_airports(self):
"""Add some airports."""
# we're not doing anything here, since:
# 1. data migrations add some airports already
# 2. we'll have more airports as fixtures as of #626
pass
def fake_roles(self):
self.stdout.write('Generating fake roles...')
roles = [
('helper', 'Helper'),
('instructor', 'Instructor'),
('host', 'Workshop host'),
('learner', 'Learner'),
('organizer', 'Workshop organizer'),
('contributor', 'Contributed to lesson materials')
]
"""Provide fixed roles (before they end up in fixtures, see #626)."""
for name, verbose_name in roles:
Role.objects.create(name=name, verbose_name=verbose_name)
def fake_groups(self):
# Two groups are already in the migrations: Administrator
# and Steering Committee
self.stdout.write('Generating fake groups...')
Group.objects.create(name='invoicing')
Group.objects.create(name='trainers')
def fake_tags(self):
"""Provide fixed tags (before they end up in fixtures, see #626)."""
self.stdout.write('Generating fake tags...')
tags = [
('SWC', 'Software Carpentry Workshop'),
('DC', 'Data Carpentry Workshop'),
('LC', 'Library Carpentry Workshop'),
('WiSE', 'Women in Science and Engineering'),
('TTT', 'Train the Trainers'),
]
for tag, details in tags:
Tag.objects.create(name=tag, details=details)
def fake_badges(self):
"""Provide fixed badges (before they end up in fixtures, see #626)."""
# 4 badges are already in the migrations: swc-instructor,
# dc-instructor, maintainer, and trainer
self.stdout.write('Generating fake badges...')
badges = [
('creator', 'Creator',
'Creating learning materials and other content'),
('member', 'Member', 'Software Carpentry Foundation member'),
('organizer', 'Organizer',
'Organizing workshops and learning groups'),
]
for name, title, criteria in badges:
Badge.objects.create(name=name, title=title, criteria=criteria)
def fake_instructors(self, count=30):
self.stdout.write('Generating {} fake instructors...'.format(count))
for _ in range(count):
self.fake_person(is_instructor=True)
def fake_trainers(self, count=10):
self.stdout.write('Generating {} fake trainers...'.format(count))
for _ in range(count):
self.fake_person(is_instructor=True, is_trainer=True)
def fake_admins(self, count=10):
self.stdout.write('Generating {} fake admins...'.format(count))
for _ in range(count):
person = self.fake_person(is_instructor=randbool(0.5))
person.groups.add(choice(Group.objects.all()))
person.is_active = True
person.set_password(person.username)
person.save()
def fake_trainees(self, count=30):
self.stdout.write('Generating {} fake trainees '
'(and their training progresses '
'as well as training requests)...'.format(count))
for _ in range(count):
p = self.fake_person(is_instructor=randbool(0.1))
training = choice(Event.objects.ttt())
Task.objects.create(person=p, event=training,
role=Role.objects.get(name='learner'))
self.fake_training_progresses(p, training)
if randbool(0.8):
self.fake_training_request(p)
def fake_training_progresses(self, p, training):
trainers = Person.objects.filter(award__badge__name='trainer')
for r in TrainingRequirement.objects.all():
if randbool(0.4):
if 'Homework' in r.name and randbool(0.5):
state = 'n'
else:
state = 'p' if randbool(0.95) else 'f'
evaluated_by = None if state == 'n' else choice(trainers)
event = training if r.name == 'Training' else None
url = self.faker.url() if 'Homework' in r.name else None
TrainingProgress.objects.create(
trainee=p,
requirement=r,
evaluated_by=evaluated_by,
state=state,
discarded=randbool(0.05),
event=event,
url=url,
notes='',
)
def fake_training_request(self, person_or_None):
if person_or_None is None:
state = 'p' if randbool(0.5) else 'd'
person = self.fake_person(is_instructor=False)
else:
state = 'a'
person = person_or_None
occupation = choice(ProfileUpdateRequest.OCCUPATION_CHOICES)[0]
req = TrainingRequest.objects.create(
state=state,
person=person_or_None,
group_name=self.faker.city() if randbool(0.1) else '',
personal=person.personal,
middle='',
family=person.family,
email=person.email,
github=person.github,
occupation=occupation,
occupation_other=self.faker.job() if occupation == '' else '',
affiliation=person.affiliation,
location=self.faker.city(),
country=choice(Countries)[0],
domains_other='',
gender=person.gender,
gender_other='',
previous_training=choice(
TrainingRequest.PREVIOUS_TRAINING_CHOICES)[0],
previous_training_other='',
previous_training_explanation=self.faker.text(),
previous_experience=choice(
TrainingRequest.PREVIOUS_EXPERIENCE_CHOICES)[0],
previous_experience_other='',
programming_language_usage_frequency=choice(
TrainingRequest.PROGRAMMING_LANGUAGE_USAGE_FREQUENCY_CHOICES)[0],
reason=self.faker.text(),
teaching_frequency_expectation=choice(
TrainingRequest.TEACHING_FREQUENCY_EXPECTATION_CHOICES)[0],
teaching_frequency_expectation_other='',
max_travelling_frequency=choice(
TrainingRequest.MAX_TRAVELLING_FREQUENCY_CHOICES)[0],
max_travelling_frequency_other='',
additional_skills=self.faker.job() if randbool(0.2) else '',
comment=self.faker.text() if randbool(0.3) else '',
)
req.domains = sample(KnowledgeDomain.objects.all())
req.previous_involvement = sample(Role.objects.all())
if person_or_None is None:
person.delete()
def fake_person(self, *, is_instructor, is_trainer=False):
airport = choice(Airport.objects.all())
email = choice([self.faker.email(),
self.faker.safe_email(),
self.faker.free_email(),
self.faker.company_email()])
gender = choice(Person.GENDER_CHOICES)[0]
if gender == 'F':
personal_name = self.faker.first_name_female()
family_name = self.faker.last_name_female()
elif gender == 'M':
personal_name = self.faker.first_name_male()
family_name = self.faker.last_name_male()
else:
personal_name = self.faker.first_name()
family_name = self.faker.last_name()
social_username = self.faker.user_name()
if randbool(0.6):
# automatically generate username
username = create_username(personal_name, family_name)
else:
# assume that the username is provided by the person
username = social_username
github = social_username if randbool(0.5) else None
twitter = social_username if randbool(0.5) else None
url = self.faker.url() if randbool(0.5) else ''
person = Person.objects.create(
personal=personal_name,
family=family_name,
email=email,
gender=gender,
may_contact=randbool(0.5),
airport=airport,
twitter=twitter,
github=github,
url=url,
username=username,
)
if is_instructor:
# Add one or more instructor badges
awards = []
badges = sample(Badge.objects.instructor_badges())
for badge in badges:
date = self.faker.date_time_between(start_date='-5y').date()
awards.append(Award(person=person, badge=badge, awarded=date))
Award.objects.bulk_create(awards)
if randbool(0.75):
# Add one or more qualifications
Qualification.objects.bulk_create(
Qualification(person=person, lesson=lesson)
for lesson in sample(Lesson.objects.all())
)
if is_trainer:
date = self.faker.date_time_between(start_date='-5y').date()
trainer = Badge.objects.get(name='trainer')
Award.objects.create(person=person, badge=trainer, awarded=date)
return person
def fake_organizations(self, count=10):
"""Add some organizations that host events."""
self.stdout.write('Generating {} fake organizations...'.format(count))
for _ in range(count):
Organization.objects.create(
domain=self.faker.domain_name(),
fullname=self.faker.company(),
country=choice(Countries)[0],
)
def fake_memberships(self, count=10):
self.stdout.write('Generating {} fake memberships...'.format(count))
for _ in range(count):
start = self.faker.date_time_between(start_date='-5y').date()
Membership.objects.create(
variant=choice(Membership.MEMBERSHIP_CHOICES),
agreement_start=start,
agreement_end=start + timedelta(days=365),
contribution_type=choice(Membership.CONTRIBUTION_CHOICES),
workshops_without_admin_fee_per_year=randint(5, 15),
self_organized_workshops_per_year=randint(5, 15),
notes='',
organization=choice(Organization.objects.all()),
)
def fake_current_events(self, count=5, **kwargs):
"""Ongoing and upcoming events."""
self.stdout.write('Generating {} fake current events...'.format(count))
for _ in range(count):
self.fake_event(**kwargs)
def fake_uninvoiced_events(self, count=5):
"""Preferably in the past, and with 'uninvoiced' status."""
self.stdout.write(
'Generating {} fake uninvoiced events...'.format(count))
for _ in range(count):
e = self.fake_event()
e.invoice_status = 'not-invoiced'
e.save()
def fake_unpublished_events(self, count=5):
"""Events with missing location data (which is required for publishing
them)."""
self.stdout.write(
'Generating {} fake unpublished events...'.format(count))
for _ in range(count):
self.fake_event(location_data=False)
def fake_self_organized_events(self, count=5):
"""Full-blown events with 'self-organized' host."""
self.stdout.write(
'Generating {} fake self organized events...'.format(count))
for _ in range(count):
e = self.fake_event(self_organized=True)
e.invoice_status = choice(Event.INVOICED_CHOICES)[0]
e.save()
def fake_ttt_events(self, count=10):
self.stdout.write(
'Generating {} fake train-the-trainer events...'.format(count))
for _ in range(count):
e = self.fake_event()
e.slug += '-ttt'
e.tags.set([Tag.objects.get(name='TTT')])
e.save()
def fake_event(self, *, location_data=True, self_organized=False,
add_tags=True):
start = self.faker.date_time_between(start_date='-5y').date()
city = self.faker.city().replace(' ', '-').lower()
if self_organized:
org = Organization.objects.get(domain='self-organized')
else:
org = choice(Organization.objects.exclude(domain='self-organized'))
# The following line may result in IntegrityError from time to time,
# because we don't guarantee that the url is unique. In that case,
# simply create new database (rm db.sqlite3 && python manage.py migrate)
# and rerun fake_database command (python manage.py fake_database). Be
# aware that creating a database deletes all data in the existing
# database!
e = Event.objects.create(
slug='{:%Y-%m-%d}-{}'.format(start, city),
start=start,
end=start + timedelta(days=2),
url=self.faker.unique_url(),
host=org,
# needed in order for event to be published
country=choice(Countries)[0] if location_data else None,
venue=self.faker.word().title() if location_data else '',
address=self.faker.street_address() if location_data else '',
latitude=uniform(-90, 90) if location_data else None,
longitude=uniform(0, 180) if location_data else None,
metadata_changed=randbool(0.1),
)
if add_tags:
e.tags = sample(Tag.objects.exclude(name='TTT'), 2)
return e
def fake_tasks(self, count=120):
self.stdout.write('Generating {} fake tasks...'.format(count))
events = Event.objects.all()
persons = Person.objects.all()
roles = Role.objects.all()
all_possible = itertools.product(events, persons, roles)
for event, person, role in sample(all_possible, count):
Task.objects.create(
event=event,
person=person,
role=role,
title=(self.faker.sentence(nb_words=4, variable_nb_words=True)
if randbool(0.2) else ''),
url=self.faker.url() if randbool(0.2) else '',
)
def fake_unmatched_training_requests(self, count=20):
self.stdout.write('Generating {} fake unmatched '
'training requests...'.format(count))
for _ in range(count):
self.fake_training_request(None)
def fake_duplicated_people(self, count=5):
self.stdout.write('Generating {} fake '
'people duplications...'.format(count))
for _ in range(count):
p = Person.objects.order_by('?').first()
p.id = None
# avoid integrity errors due to unique constraints
p.username = create_username(p.personal, p.family)
p.twitter = None
p.github = None
p.email = self.faker.email()
p.save()
def fake_workshop_requests(self, count=10):
self.stdout.write('Generating {} fake '
'workshop requests...'.format(count))
for _ in range(count):
if randbool(0.5):
language = Language.objects.get(subtag='en')
else:
language = choice(Language.objects.all())
req = EventRequest.objects.create(
name=self.faker.name(),
email=self.faker.email(),
affiliation=self.faker.company(),
location=self.faker.city(),
country=choice(Countries)[0],
conference='',
preferred_date=str(self.faker.date_time_between(
start_date='now', end_date='+1y').date()),
language=language,
workshop_type=choice(EventRequest.WORKSHOP_TYPE_CHOICES)[0],
approx_attendees=choice(
EventRequest.ATTENDEES_NUMBER_CHOICES)[0],
attendee_domains_other='',
data_types=choice(EventRequest.DATA_TYPES_CHOICES)[0],
understand_admin_fee=True,
admin_fee_payment=choice(
EventRequest.ADMIN_FEE_PAYMENT_CHOICES)[0],
fee_waiver_request=randbool(0.2),
cover_travel_accomodation=randbool(0.6),
travel_reimbursement=choice(
EventRequest.TRAVEL_REIMBURSEMENT_CHOICES)[0],
travel_reimbursement_other='',
comment='',
)
req.attendee_domains = sample(KnowledgeDomain.objects.all())
req.attendee_academic_levels = sample(AcademicLevel.objects.all())
req.attendee_computing_levels = sample(
ComputingExperienceLevel.objects.all())
req.attendee_data_analysis_level = sample(
DataAnalysisLevel.objects.all())
req.save()
def fake_workshop_submissions(self, count=10):
self.stdout.write('Generating {} fake '
'workshop submissions...'.format(count))
for _ in range(count):
EventSubmission.objects.create(
url=self.faker.url(),
contact_name=self.faker.name(),
contact_email=self.faker.email(),
self_organized=randbool(0.5),
notes='',
)
def fake_dc_selforganized_workshop_requests(self, count=5):
self.stdout.write('Generating {} fake dc self-organized '
'workshops requests...'.format(count))
for _ in range(count):
date = self.faker.date_time_between(start_date='now',
end_date='+1y')
req = DCSelfOrganizedEventRequest.objects.create(
name=self.faker.name(),
email=self.faker.email(),
organization=self.faker.company(),
instructor_status=choice(
DCSelfOrganizedEventRequest.INSTRUCTOR_CHOICES)[0],
is_partner=choice(
DCSelfOrganizedEventRequest.PARTNER_CHOICES)[0],
is_partner_other='',
location=self.faker.city(),
country=choice(Countries)[0],
associated_conference='',
dates=str(date.date()),
domains_other='',
topics_other='',
payment=choice(DCSelfOrganizedEventRequest.PAYMENT_CHOICES)[0],
fee_waiver_reason='',
handle_registration=True,
distribute_surveys=True,
follow_code_of_conduct=True,
)
req.domains = sample(DCWorkshopDomain.objects.all())
req.topics = sample(DCWorkshopTopic.objects.all())
req.attendee_academic_levels = sample(AcademicLevel.objects.all())
req.attendee_data_analysis_level = sample(
DataAnalysisLevel.objects.all())
def fake_profile_update_requests(self, count=20):
self.stdout.write('Generating {} fake '
'profile update requests...'.format(count))
for _ in range(count):
p = Person.objects.order_by('?').first() # type: Person
req = ProfileUpdateRequest.objects.create(
active=randbool(0.5),
personal=(p.personal if randbool(0.9)
else self.faker.first_name()),
middle=p.middle,
family=p.family if randbool(0.9) else self.faker.last_name(),
email=p.email if randbool(0.8) else self.faker.email(),
affiliation=(p.affiliation if randbool(0.8)
else self.faker.company()),
airport_iata=(p.airport.iata
if randbool(0.9) and p.airport is not None
else choice(Airport.objects.all()).iata),
occupation=choice(ProfileUpdateRequest.OCCUPATION_CHOICES)[0],
occupation_other='',
github=p.github or '',
twitter=p.twitter or '',
orcid=p.orcid or '',
website=p.url or '',
gender=choice(ProfileUpdateRequest.GENDER_CHOICES)[0],
gender_other='',
domains_other='',
lessons_other='',
notes='',
)
req.domains = (p.domains.all() if randbool(0.9) else
sample(KnowledgeDomain.objects.all()))
req.languages = (p.languages.all() if randbool(0.9) else
sample(Language.objects.all()))
req.lessons = (p.lessons.all() if randbool(0.9) else
sample(Lesson.objects.all()))
def fake_invoice_requests(self, count=10):
self.stdout.write('Generating {} fake '
'invoice requests...'.format(count))
for _ in range(count):
status = choice(InvoiceRequest.STATUS_CHOICES)[0]
sent_date = (None if status == 'not-invoiced' else
self.faker.date_time_between(start_date='-1y').date())
paid_date = (
self.faker.date_time_between(start_date=sent_date).date()
if status == 'paid' else None)
org = Organization.objects.order_by('?').first()
event = (Event.objects.order_by('?').first()
if randbool(0.8) else None)
req = InvoiceRequest.objects.create(
status=status,
sent_date=sent_date,
paid_date=paid_date,
organization=org,
reason=choice(InvoiceRequest.INVOICE_REASON)[0],
reason_other='',
date=(self.faker.date_time_between(start_date='-1y').date()
if sent_date is None else sent_date),
event=event,
event_location='',
item_id='',
postal_number='',
contact_name=org.fullname,
contact_email=self.faker.email(),
contact_phone='',
full_address=self.faker.address(),
amount=choice([1000, 2000, 10000]),
currency=choice(InvoiceRequest.CURRENCY)[0],
currency_other='',
breakdown='',
vendor_form_required=
choice(InvoiceRequest.VENDOR_FORM_CHOICES)[0],
vendor_form_link='',
form_W9=randbool(0.5),
receipts_sent=choice(InvoiceRequest.RECEIPTS_CHOICES)[0],
shared_receipts_link='',
notes='',
)
def handle(self, *args, **options):
seed = options['seed']
if seed is not None:
self.faker.seed(seed)
self.fake_airports()
self.fake_roles()
self.fake_groups()
self.fake_tags()
self.fake_badges()
self.fake_instructors()
self.fake_trainers()
self.fake_admins()
self.fake_organizations()
self.fake_memberships()
self.fake_current_events()
self.fake_uninvoiced_events()
self.fake_unpublished_events()
self.fake_self_organized_events()
self.fake_ttt_events()
self.fake_tasks()
self.fake_trainees()
self.fake_unmatched_training_requests()
self.fake_duplicated_people()
self.fake_workshop_requests()
self.fake_workshop_submissions()
self.fake_dc_selforganized_workshop_requests()
self.fake_profile_update_requests()
self.fake_invoice_requests()
class Command(BaseCommand):
help = 'Add fake data to the database.'
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.faker = Faker()
self.faker.add_provider(UniqueUrlProvider)
def add_arguments(self, parser):
parser.add_argument(
'--seed', action='store', default=None,
help='Provide an initial seed for randomization mechanism.',
)
def fake_airports(self):
"""Add some airports."""
# we're not doing anything here, since data migrations already add some
# airports
self.stdout.write('Generating 0 fake airports...')
def fake_roles(self):
"""Provide fixed roles."""
roles = [
('helper', 'Helper'),
('instructor', 'Instructor'),
('host', 'Workshop host'),
('learner', 'Learner'),
('organizer', 'Workshop organizer'),
('contributor', 'Contributed to lesson materials')
]
self.stdout.write('Generating {} fake roles...'.format(len(roles)))
for name, verbose_name in roles:
Role.objects.get_or_create(
name=name,
defaults=dict(verbose_name=verbose_name)
)
def fake_groups(self):
"""Provide authentication groups."""
groups = ['administrators', 'invoicing', 'steering committee',
'trainers']
self.stdout.write(
'Generating {} auth groups...'.format(len(groups)))
for group in groups:
Group.objects.get_or_create(name=group)
def fake_tags(self):
"""Provide fixed tags. All other tags are pre-created through data
migrations."""
tags = [
('SWC', 'Software Carpentry Workshop'),
('DC', 'Data Carpentry Workshop'),
('LC', 'Library Carpentry Workshop'),
('WiSE', 'Women in Science and Engineering'),
('TTT', 'Train the Trainers'),
('online', 'Events taking place entirely online'),
('stalled', 'Events with lost contact with the host or TTT events'
' that aren\'t running.'),
('unresponsive', 'Events whose hosts and/or organizers aren\'t '
'going to send attendance data'),
('hackathon', 'Event is a hackathon'),
('cancelled', 'Events that were supposed to happen but due to some'
' circumstances got cancelled'),
('LSO', 'Lesson Specific Onboarding'),
('ITT', 'Instructor Trainer Training (Trainer Training)'),
('LMO', 'Lesson Maintainer Onboarding'),
]
self.stdout.write('Generating {} fake tags...'.format(len(tags)))
for tag, details in tags:
Tag.objects.get_or_create(name=tag, defaults=dict(details=details))
def fake_badges(self):
"""Provide fixed badges."""
badges = [
('creator', 'Creator', 'Creating learning materials and other '
'content'),
('swc-instructor', 'Software Carpentry Instructor',
'Teaching at Software Carpentry workshops or online'),
('member', 'Member', 'Software Carpentry Foundation member'),
('organizer', 'Organizer', 'Organizing workshops and learning '
'groups'),
('dc-instructor', 'Data Carpentry Instructor',
'Teaching at Data Carpentry workshops or online'),
('maintainer', 'Maintainer', 'Maintainer of Software or Data '
'Carpentry lesson'),
('trainer', 'Trainer', 'Teaching instructor training workshops'),
('mentor', 'Mentor', 'Mentor of Carpentry Instructors'),
('mentee', 'Mentee', 'Mentee in Carpentry Mentorship Program'),
('lc-instructor', 'Library Carpentry Instructor',
'Teaching at Library Carpentry workshops or online'),
]
self.stdout.write('Generating {} fake badges...'.format(len(badges)))
for name, title, criteria in badges:
Badge.objects.get_or_create(
name=name, defaults=dict(title=title, criteria=criteria))
def fake_instructors(self, count=30):
self.stdout.write('Generating {} fake instructors...'.format(count))
for _ in range(count):
self.fake_person(is_instructor=True)
def fake_trainers(self, count=10):
self.stdout.write('Generating {} fake trainers...'.format(count))
for _ in range(count):
self.fake_person(is_instructor=True, is_trainer=True)
def fake_admins(self, count=10):
self.stdout.write('Generating {} fake admins...'.format(count))
for _ in range(count):
person = self.fake_person(is_instructor=randbool(0.5))
person.groups.add(choice(Group.objects.all()))
person.is_active = True
person.set_password(person.username)
person.save()
def fake_trainees(self, count=30):
self.stdout.write('Generating {} fake trainees (and their training '
'progresses and training requests)...'.format(count))
for _ in range(count):
p = self.fake_person(is_instructor=randbool(0.1))
training = choice(Event.objects.ttt())
Task.objects.create(person=p, event=training,
role=Role.objects.get(name='learner'))
self.fake_training_request(p)
self.fake_training_progresses(p, training)
def fake_training_progresses(self, p, training):
trainers = Person.objects.filter(award__badge__name='trainer')
for r in TrainingRequirement.objects.all():
if randbool(0.4):
if 'Homework' in r.name and randbool(0.5):
state = 'n'
else:
state = 'p' if randbool(0.95) else 'f'
evaluated_by = None if state == 'n' else choice(trainers)
event = training if r.name == 'Training' else None
url = self.faker.url() if 'Homework' in r.name else None
TrainingProgress.objects.create(
trainee=p,
requirement=r,
evaluated_by=evaluated_by,
state=state,
discarded=randbool(0.05),
event=event,
url=url,
notes='',
)
def fake_training_request(self, person_or_None):
if person_or_None is None:
state = 'p' if randbool(0.5) else 'd'
person = self.fake_person(is_instructor=False)
else:
state = 'a'
person = person_or_None
occupation = choice(TrainingRequest._meta.get_field('occupation')
.choices)[0]
training_completion_agreement = randbool(0.5)
underrepresented_choices = (
TrainingRequest._meta.get_field('underrepresented').choices
)
req = TrainingRequest.objects.create(
state=state,
person=person_or_None,
group_name=self.faker.city() if randbool(0.1) else '',
personal=person.personal,
middle='',
family=person.family,
email=person.email,
github=person.github,
occupation=occupation,
occupation_other=self.faker.job() if occupation == '' else '',
affiliation=person.affiliation,
location=self.faker.city(),
country=choice(Countries)[0],
underresourced=randbool(0.6),
domains_other='',
underrepresented=choice(underrepresented_choices)[0],
underrepresented_details=choice(
['', self.faker.paragraph(nb_sentences=1)]
),
nonprofit_teaching_experience='',
previous_training=choice(
TrainingRequest.PREVIOUS_TRAINING_CHOICES)[0],
previous_training_other='',
previous_training_explanation=self.faker.text(),
previous_experience=choice(
TrainingRequest.PREVIOUS_EXPERIENCE_CHOICES)[0],
previous_experience_other='',
programming_language_usage_frequency=choice(
TrainingRequest.PROGRAMMING_LANGUAGE_USAGE_FREQUENCY_CHOICES)[0],
teaching_frequency_expectation=choice(
TrainingRequest.TEACHING_FREQUENCY_EXPECTATION_CHOICES)[0],
teaching_frequency_expectation_other='',
max_travelling_frequency=choice(
TrainingRequest.MAX_TRAVELLING_FREQUENCY_CHOICES)[0],
max_travelling_frequency_other='',
reason=self.faker.text(),
training_completion_agreement=training_completion_agreement,
workshop_teaching_agreement=randbool(0.5) if training_completion_agreement else False,
)
req.domains.set(sample(KnowledgeDomain.objects.all()))
req.previous_involvement.set(sample(Role.objects.all()))
if person_or_None is None:
person.delete()
def fake_person(self, *, is_instructor, is_trainer=False):
airport = choice(Airport.objects.all())
email = choice([self.faker.email(),
self.faker.safe_email(),
self.faker.free_email(),
self.faker.company_email()])
gender = choice(Person.GENDER_CHOICES)[0]
if gender == 'F':
personal_name = self.faker.first_name_female()
family_name = self.faker.last_name_female()
elif gender == 'M':
personal_name = self.faker.first_name_male()
family_name = self.faker.last_name_male()
else:
personal_name = self.faker.first_name()
family_name = self.faker.last_name()
social_username = self.faker.user_name()
if randbool(0.6):
# automatically generate username
username = create_username(personal_name, family_name)
else:
# assume that the username is provided by the person
username = social_username
github = social_username
twitter = social_username
url = self.faker.url() if randbool(0.5) else ''
person = Person.objects.create(
personal=personal_name,
family=family_name,
email=email,
gender=gender,
may_contact=randbool(0.5),
publish_profile=randbool(0.5),
airport=airport,
twitter=twitter,
github=github,
url=url,
username=username,
country=choice(Countries)[0],
)
if is_instructor:
# Add one or more instructor badges
awards = []
badges = sample(Badge.objects.instructor_badges())
for badge in badges:
date = self.faker.date_time_between(start_date='-5y').date()
awards.append(Award(person=person, badge=badge, awarded=date))
Award.objects.bulk_create(awards)
if randbool(0.75):
# Add one or more qualifications
Qualification.objects.bulk_create(
Qualification(person=person, lesson=lesson)
for lesson in sample(Lesson.objects.all())
)
if is_trainer:
date = self.faker.date_time_between(start_date='-5y').date()
trainer = Badge.objects.get(name='trainer')
Award.objects.create(person=person, badge=trainer, awarded=date)
return person
def fake_organizations(self, count=10):
"""Add some organizations that host events."""
self.stdout.write('Generating {} fake organizations...'.format(count))
for _ in range(count):
Organization.objects.create(
domain=self.faker.domain_name(),
fullname=self.faker.company(),
country=choice(Countries)[0],
)
def fake_memberships(self, count=10):
self.stdout.write('Generating {} fake memberships...'.format(count))
for _ in range(count):
start = self.faker.date_time_between(start_date='-5y').date()
Membership.objects.create(
variant=choice(Membership.MEMBERSHIP_CHOICES)[0],
agreement_start=start,
agreement_end=start + timedelta(days=365),
contribution_type=choice(Membership.CONTRIBUTION_CHOICES)[0],
workshops_without_admin_fee_per_agreement=randint(5, 15),
self_organized_workshops_per_agreement=randint(5, 15),
organization=choice(Organization.objects.all()),
)
def fake_current_events(self, count=5, **kwargs):
"""Ongoing and upcoming events."""
self.stdout.write('Generating {} fake current events...'.format(count))
for _ in range(count):
self.fake_event(future_date=True, **kwargs)
def fake_unpublished_events(self, count=5):
"""Events with missing location data (which is required for publishing
them)."""
self.stdout.write(
'Generating {} fake unpublished events...'.format(count))
for _ in range(count):
self.fake_event(location_data=False)
def fake_self_organized_events(self, count=5):
"""Full-blown events with 'self-organized' host."""
self.stdout.write(
'Generating {} fake self organized events...'.format(count))
for _ in range(count):
e = self.fake_event(self_organized=True)
e.invoice_status = choice(Event.INVOICED_CHOICES)[0]
e.save()
def fake_ttt_events(self, count=10):
self.stdout.write(
'Generating {} fake train-the-trainer events...'.format(count))
for _ in range(count):
e = self.fake_event()
e.slug += '-ttt'
e.tags.set([Tag.objects.get(name='TTT')])
e.save()
def fake_event(self, *, location_data=True, self_organized=False,
add_tags=True, future_date=False):
if future_date:
start = self.faker.date_time_between(start_date='now',
end_date='+120d').date()
else:
start = self.faker.date_time_between(start_date='-120d').date()
city = self.faker.city().replace(' ', '-').lower()
if self_organized:
org = Organization.objects.get(domain='self-organized')
else:
org = choice(Organization.objects.exclude(domain='self-organized'))
# The following line may result in IntegrityError from time to time,
# because we don't guarantee that the url is unique. In that case,
# simply create new database (rm db.sqlite3 && python manage.py migrate)
# and rerun fake_database command (python manage.py fake_database). Be
# aware that creating a database deletes all data in the existing
# database!
e = Event.objects.create(
slug='{:%Y-%m-%d}-{}'.format(start, city),
start=start,
end=start + timedelta(days=2),
url=self.faker.unique_url(),
host=org,
# needed in order for event to be published
country=choice(Countries)[0] if location_data else None,
venue=self.faker.word().title() if location_data else '',
address=self.faker.street_address() if location_data else '',
latitude=uniform(-90, 90) if location_data else None,
longitude=uniform(0, 180) if location_data else None,
metadata_changed=randbool(0.1),
)
if add_tags:
e.tags.set(sample(Tag.objects.exclude(name='TTT'), 2))
return e
def fake_tasks(self, count=120):
self.stdout.write('Generating {} fake tasks...'.format(count))
events = Event.objects.all()
persons = Person.objects.all()
roles = Role.objects.all()
all_possible = itertools.product(events, persons, roles)
for event, person, role in sample(all_possible, count):
Task.objects.create(
event=event,
person=person,
role=role,
title=(self.faker.sentence(nb_words=4, variable_nb_words=True)
if randbool(0.2) else ''),
url=self.faker.url() if randbool(0.2) else '',
)
def fake_unmatched_training_requests(self, count=20):
self.stdout.write('Generating {} fake unmatched '
'training requests...'.format(count))
for _ in range(count):
self.fake_training_request(None)
def fake_duplicated_people(self, count=5):
self.stdout.write('Generating {} fake '
'people duplications...'.format(count))
for _ in range(count):
p = Person.objects.order_by('?').first()
p.id = None
# avoid integrity errors due to unique constraints
p.username = create_username(p.personal, p.family)
p.twitter = None
p.github = None
p.email = self.faker.email()
p.save()
def fake_workshop_requests(self, count=10):
self.stdout.write('Generating {} fake '
'workshop requests...'.format(count))
curricula = Curriculum.objects.filter(active=True)
organizations = Organization.objects.all()
for _ in range(count):
if randbool(0.5):
language = Language.objects.get(subtag='en')
else:
language = choice(Language.objects.all())
if randbool(0.3):
org = choice(organizations)
org_name = ''
else:
org = None
org_name = self.faker.company()
organization_type = choice(
WorkshopRequest.ORGANIZATION_TYPE_CHOICES)[0]
if organization_type == 'self':
self_organized_github = self.faker.uri()
centrally_organized_fee = 'nonprofit' # doesn't matter
waiver_circumstances = ""
travel_expences_agreement = False
travel_expences_management = ""
travel_expences_management_other = ""
else:
self_organized_github = ""
centrally_organized_fee = choice(WorkshopRequest.FEE_CHOICES)[0]
waiver_circumstances = (
self.faker.sentence()
if centrally_organized_fee == 'waiver'
else "")
travel_expences_agreement = True
travel_expences_management = choice(
WorkshopRequest.TRAVEL_EXPENCES_MANAGEMENT_CHOICES)[0]
travel_expences_management_other = (
self.faker.sentence()
if travel_expences_management == ''
else "")
req = WorkshopRequest.objects.create(
state=choice(['p', 'd', 'a']),
data_privacy_agreement=randbool(0.5),
code_of_conduct_agreement=randbool(0.5),
host_responsibilities=randbool(0.5),
personal=self.faker.first_name(),
family=self.faker.last_name(),
email=self.faker.email(),
institution=org,
institution_name=org_name,
institution_department='',
location=self.faker.city(),
country=choice(Countries)[0],
conference_details='',
preferred_dates=str(self.faker.date_time_between(
start_date='now', end_date='+1y').date()),
language=language,
number_attendees=choice(
WorkshopRequest.ATTENDEES_NUMBER_CHOICES)[0],
# domains=[], # will be selected below because it's M2M
domains_other='',
# academic_levels=[], # will be selected below
# computing_levels=[], # will be selected below
audience_description=self.faker.sentence(),
# requested_workshop_types=[], # will be selected below
organization_type=organization_type,
self_organized_github=self_organized_github,
centrally_organized_fee=centrally_organized_fee,
waiver_circumstances=waiver_circumstances,
travel_expences_agreement=travel_expences_agreement,
travel_expences_management=travel_expences_management,
travel_expences_management_other=travel_expences_management_other,
user_notes = self.faker.sentence(),
)
req.domains.set(sample(KnowledgeDomain.objects.all()))
req.academic_levels.set(sample(AcademicLevel.objects.all()))
req.computing_levels.set(sample(ComputingExperienceLevel.objects.all()))
req.requested_workshop_types.set(sample(curricula))
req.save()
def handle(self, *args, **options):
seed = options['seed']
if seed is not None:
self.faker.seed(seed)
try:
self.fake_groups()
self.fake_airports()
self.fake_roles()
self.fake_tags()
self.fake_badges()
self.fake_instructors()
self.fake_trainers()
self.fake_admins()
self.fake_organizations()
self.fake_memberships()
self.fake_current_events()
self.fake_unpublished_events()
self.fake_self_organized_events()
self.fake_ttt_events()
self.fake_tasks()
self.fake_trainees()
self.fake_unmatched_training_requests()
self.fake_duplicated_people()
self.fake_workshop_requests()
except IntegrityError as e:
print("!!!" * 10)
print("Delete the database, and rerun this script.")
print("!!!" * 10)
raise e
base_font_size -= 2
font = ImageFont.truetype(font_path, base_font_size)
w, h = draw.textsize(msg, font=font)
draw.text(((width - w) / 2, (height - h) / 2), msg, fill=font_color, font=font)
tmp_content = StringIO()
im.save(tmp_content, format=image_format)
if VERSION < (1, 4):
return ContentFile(tmp_content.getvalue())
file_name = uuid.uuid4().__str__() + ".%s" % image_format
return ContentFile(tmp_content.getvalue(), name=file_name)
fake.add_provider(CustomProvider)
###########################################################
# CUSTOM MOMMY MAPPINGS
###########################################################
# Value generators based on field type
mommy.default_mapping.update(
{
CharField: fake.sentence,
TextField: fake.text,
SlugField: lambda: None,
URLField: fake.url,
EmailField: fake.email,
}
