class APISeedTestCase(unittest.TestCase):
def setUp(self):
self.seed1 = Seed()
self.seed2 = Seed()
def test_django_seed_singleton(self):
self.assertEqual(self.seed1, self.seed2)
self.assertIs(self.seed1, self.seed1)
def test_faker_cache_faker(self):
gen1 = self.seed1.faker()
gen2 = self.seed2.faker()
self.assertIs(gen1, gen2)
gen1 = self.seed1.faker(codename='default')
gen2 = self.seed2.faker(codename='default')
self.assertIs(gen1, gen2)
gen1 = self.seed1.faker(locale='it_IT')
gen2 = self.seed2.faker(locale='it_IT')
self.assertIs(gen1, gen2)
def test_faker_cache_seeder(self):
seeder1 = self.seed1.seeder()
seeder2 = self.seed2.seeder()
self.assertIs(seeder1, seeder2)
gen1 = seeder1.faker
gen2 = seeder2.faker
self.assertIs(gen1, gen2)
seeder1 = self.seed1.seeder(locale='it_IT')
seeder2 = self.seed2.seeder(locale='it_IT')
self.assertIs(seeder1, seeder2)
def handle_app_config(self, app_config, **options):
if app_config.models_module is None:
raise SeederCommandError('You must provide an app to seed')
try:
number = int(options['number'])
except ValueError:
raise SeederCommandError('The value of --number must be an integer')
seeder = Seed.seeder()
for model in self.sorted_models(app_config):
seeder.add_entity(model, number)
print('Seeding %i %ss' % (number, model.__name__))
pks = seeder.execute()
print(pks)
def handle(self, *args, **options):
number = options.get("number")
orders = Order.objects.all()
products = Product.objects.all()
materials = Material.objects.all()
prices = [12000, 9000, 13000]
seeder = Seed.seeder()
seeder.add_entity(
OrderItem,
number,
{
"order": lambda x: random.choice(orders),
"product": lambda x: random.choice(products),
"quantity": lambda x: random.randint(1, 3),
"price": lambda x: random.choice(prices),
"outsole_color_left": randomColor(),
"midsole_color_left": randomColor(),
"uppersole_color_left": randomColor(),
"shoelace_color_left": randomColor(),
"tongue_color_left": randomColor(),
"outsole_color_right": randomColor(),
"midsole_color_right": randomColor(),
"uppersole_color_right": randomColor(),
"shoelace_color_right": randomColor(),
"tongue_color_right": randomColor(),
"outsole_material_left": random.choice(materials),
"midsole_material_left": random.choice(materials),
"uppersole_material_left": random.choice(materials),
"shoelace_material_left": random.choice(materials),
"tongue_material_left": random.choice(materials),
"outsole_material_right": random.choice(materials),
"midsole_material_right": random.choice(materials),
"uppersole_material_right": random.choice(materials),
"shoelace_material_right": random.choice(materials),
"tongue_material_right": random.choice(materials),
"length_left": lambda x: random.randint(190, 300),
"length_right": lambda x: random.randint(190, 300),
"width_left": lambda x: random.randint(70, 120),
"width_right": lambda x: random.randint(70, 120),
},
)
seeder.execute()
self.stdout.write(self.style.SUCCESS(f"{number} orders created!"))
def handle(self, *args, **options):
number = options.get('number')
seeder = Seed.seeder()
all_user = user_model.User.objects.all()
room_types = room_model.RoomType.objects.all()
seeder.add_entity(
room_model.Room, number, {
'name': lambda x: seeder.faker.address(),
'host': lambda x: random.choice(all_user),
'room_type': lambda x: random.choice(room_types),
"guests": lambda x: random.randint(0, 20),
'price': lambda x: random.randint(0, 300),
'beds': lambda x: random.randint(0, 5),
'bedrooms': lambda x: random.randint(0, 5),
'baths': lambda x: random.randint(0, 5),
})
created_photos = seeder.execute()
created_clean = flatten(list(created_photos.values()))
amenities = room_model.Amenity.objects.all()
facilities = room_model.Facility.objects.all()
for pk in created_clean:
room = room_model.Room.objects.get(pk=pk)
for i in range(3, random.randint(10, 30)):
room_model.Photo.objects.create(
caption=seeder.faker.sentence(),
room=room,
file=f"/media/{random.randint(1,31)}.webp",
)
for a in amenities:
num = random.randint(0, 15)
if num % 2 == 0:
room.amenities.add(a)
for a in facilities:
num = random.randint(0, 15)
if num % 2 == 0:
room.facilities.add(a)
self.stdout.write(self.style.SUCCESS("Rooms created!"))
def handle(self, *args, **options):
total = int(options.get("total"))
seeder = Seed.seeder()
movies = Category.objects.filter(kind=Category.KIND_MOVIE)
books = Category.objects.filter(kind=Category.KIND_BOOK)
seeder.add_entity(
User,
total,
{
"is_staff": False,
"is_superuser": False,
"preference":
lambda x: choice([User.PREF_BOOKS, User.PREF_MOVIES]),
"fav_book_cat": lambda x: choice(books),
"fav_movie_cat": lambda x: choice(movies),
},
)
seeder.execute()
self.stdout.write(self.style.SUCCESS(f"{total} users created!"))
def handle(self, *args, **options):
total = int(options.get("total"))
seeder = Seed.seeder()
seeder.add_entity(
Person,
total,
{
"name":
lambda x: seeder.faker.name(),
"kind":
lambda x: choice([
Person.KIND_ACTOR, Person.KIND_DIRECTOR, Person.KIND_WRITER
]),
"photo":
lambda x: f"people/{randint(1,30)}.jpg",
},
)
seeder.execute()
self.stdout.write(self.style.SUCCESS(f"{total} people created!"))
def handle(self, *args, **options):
total = options.get("total")
seeder = Seed.seeder()
books = book_models.Book.objects.all()
movies = movie_models.Movie.objects.all()
users = user_models.User.objects.all()
seeder.add_entity(
Review,
total,
{
"movie": lambda x: random.choice(movies),
"book": lambda x: random.choice(books),
"created_by": lambda x: random.choice(users),
"rating": lambda x: random.randint(1, 5),
},
)
seeder.execute()
self.stdout.write(self.style.SUCCESS(f"{total} {NAME} created!"))
def handle(self, *labels, **options):
number = options.get("number")
seeder = Seed.seeder()
users = user_models.User.objects.all()
rooms = room_models.Room.objects.all()
seeder.add_entity(
list_models.List, number, {"user": lambda x: random.choice(users)},
)
created = seeder.execute()
cleaned = flatten(list(created.values()))
for pk in cleaned:
list_model = list_models.List.objects.get(pk=pk)
to_add = rooms[random.randint(1, 5) : random.randint(6, 10)]
print(to_add)
list_model.rooms.add(*to_add)
self.stdout.write(self.style.SUCCESS(f"{number} of lists are created!"))
def handle(self, *args, **options):
number = options.get("number")
seeder = Seed.seeder()
users = user_models.User.objects.all()
rooms = room_models.Room.objects.all()
seeder.add_entity(
list_models.List, number, {"user": lambda x: random.choice(users)}
)
created = seeder.execute()
cleaned = flatten(list(created.values()))
for pk in cleaned:
list_model = list_models.List.objects.get(pk=pk)
start_num = random.randint(0, 5)
end_num = random.randint(6, 30)
to_add = rooms[start_num:end_num]
list_model.rooms.add(*to_add)
self.stdout.write(self.style.SUCCESS(f"{number} {NAME} created!"))
def handle(self, *args, **options):
for title in 'SE SL VE VT'.split(' '):
Category.objects.update_or_create(title=title)
categories = tuple(Category.objects.all())
teachers = tuple(
get_user_model().objects.all().filter(groups__name='teacher'))
students = tuple(
get_user_model().objects.all().filter(groups__name='student'))
seeder: Seeder = Seed.seeder(locale='cz_CZ')
# seeder.add_entity(get_user_model(), 30)
seeder.add_entity(
Thesis, 10,
dict(
registration_number=lambda *_: ''.join(
(choice(string.ascii_uppercase), str(randint(100, 999)))),
published_at=lambda *_: date(randint(2004, 2020), choice(
(4, 5)), 1),
category=lambda *_: choice(categories),
title=lambda *_: choice(TITLES),
abstract=lambda *_: ' '.join(
sample(ABSTRACTS, int(triangular(5, 15)))),
reservable=lambda *_: random() > .2,
state=lambda *_: choice(Thesis.State.values),
supervisor=lambda *_: choice(teachers),
opponent=lambda *_: choice(teachers),
))
seeder.add_entity(
Reservation, 5,
dict(
state=lambda *_: choice(Reservation.State.values),
user=lambda *_: choice(students),
))
inserted = seeder.execute()
for thesis in map(lambda i: Thesis.objects.get(pk=i),
inserted[Thesis]):
thesis.authors.add(choice(students))
if random() > .85:
thesis.authors.add(choice(students))
def handle(self, *args, **options):
total = options.get("total")
seeder = Seed.seeder()
categories = category_models.Category.objects.all()
people = person_models.Person.objects.all()
seeder.add_entity(
Book,
total,
{
"category": lambda x: random.choice(categories),
"title": lambda x: seeder.faker.sentence(),
"rating": lambda x: random.randint(1, 5),
"writer": lambda x: random.choice(people),
},
)
seeder.execute()
self.stdout.write(self.style.SUCCESS(f"{total} {NAME} created!"))
def handle(self, *args, **options):
total = int(options.get("total"))
seeder = Seed.seeder()
users = User.objects.all()
movies = Movie.objects.all()
books = Book.objects.all()
seeder.add_entity(
Review,
total,
{
"created_by": lambda x: choice(users),
"text": lambda x: seeder.faker.sentence(),
"movie": lambda x: choice(movies),
"book": lambda x: choice(books),
"rating": lambda x: randint(1, 5),
},
)
seeder.execute()
self.stdout.write(self.style.SUCCESS(f"{total} reviews created!"))
def handle(self, *args, **options):
# print(args, options)
# get number from console
number = options.get("number")
seeder = Seed.seeder()
# importing foreignkey field at models.py
all_users = user_models.User.objects.all()
all_rooms = room_models.Room.objects.all()
print(all_users)
# https://docs.djangoproject.com/en/3.0/ref/models/querysets/#when-querysets-are-evaluated
# users_list = list(all_users)
# print(users_list)
# add entities to seeder packet
seeder.add_entity(
list_models.List,
number,
# foreignkey field wrapped as queryset
{"user": lambda x: random.choice(all_users)},
)
# inject seeder packet to the databse
# executing seeder
created = seeder.execute()
# allocating random rooms to list
cleaned = flatten(list(created.values()))
for pk in cleaned:
# getting list class item with primary key
list_model = list_models.List.objects.get(pk=pk)
# list of rooms from random number to random number
random_int1 = random.randint(0, 5)
random_int2 = random.randint(6, 30)
to_add = all_rooms[random_int1:random_int2]
# below is "rooms" field at lists.models class List
list_model.rooms.add(*to_add)
# stand out
self.stdout.write(self.style.SUCCESS(f"{number} {NAME} created"))
def handle(self, *args, **options):
number = options.get("number")
seeder = Seed.seeder()
all_rooms = Room.objects.all()
all_users = users_models.User.objects.all()
seeder.add_entity(
Review, number, {
"accuracy": lambda x: random.randint(0, 6),
"communication": lambda x: random.randint(0, 6),
"cleanliness": lambda x: random.randint(0, 6),
"location": lambda x: random.randint(0, 6),
"check_in": lambda x: random.randint(0, 6),
"value": lambda x: random.randint(0, 6),
"user": lambda x: random.choice(all_users),
"room": lambda x: random.choice(all_rooms),
})
seeder.execute()
self.stdout.write(
self.style.SUCCESS(f"{number} reviews created successfully!"))
def handle(self, *args, **options):
number = options.get("number")
seeder = Seed.seeder()
all_users = user_models.User.objects.all()
room_types = room_models.RoomType.objects.all()
seeder.add_entity(
room_models.Room, number, {
"name": lambda x: seeder.faker.address(),
"host": lambda x: random.choice(all_users),
"room_type": lambda x: random.choice(room_types),
"guests": lambda x: random.randint(1, 20),
"price": lambda x: random.randint(1, 300),
"beds": lambda x: random.randint(1, 5),
"bedrooms": lambda x: random.randint(1, 5),
"baths": lambda x: random.randint(1, 5),
})
created_photos = seeder.execute()
created_clean = flatten(list(created_photos.values()))
amenities = room_models.Amenity.objects.all()
facilities = room_models.Facility.objects.all()
rules = room_models.HoueseRule.objects.all()
for pk in created_clean:
room = room_models.Room.objects.get(pk=pk)
for i in range(3, random.randint(10, 30)):
room_models.Photo.objects.create(
caption=seeder.faker.sentence(),
room=room,
file=f"room_photos/{random.randint(1, 31)}.webp",
)
for a in amenities:
magic_number = random.randint(0, 15)
if magic_number % 2 == 0:
room.amenities.add(a)
for f in facilities:
magic_number = random.randint(0, 15)
if magic_number % 2 == 0:
room.facilities.add(f)
for r in rules:
magic_number = random.randint(0, 15)
if magic_number % 2 == 0:
room.house_rules.add(r)
self.stdout.write(self.style.SUCCESS(f"{number} rooms created!"))
def handle(self, *args, **options):
number = options.get("number")
seeder = Seed.seeder()
users = users_models.User.objects.all()
rooms = rooms_models.Room.objects.all()
seeder.add_entity(
lists_models.List,
number,
{
"user": lambda x: random.choice(users),
},
)
created = seeder.execute()
clean = flatten(list(created.values()))
for pk in clean:
list_model = lists_models.List.objects.get(pk=pk)
to_add = rooms[random.randint(0, 5) : random.randint(6, 30)]
list_model.rooms.add(*to_add)
self.stdout.write(f"{number} {NAME} creates")
def handle(self, *args, **options):
number = options.get('number')
seeder = Seed.seeder()
user = User.objects.filter(is_superuser=False)
room = Room.objects.all()
seeder.add_entity(
Review, number, {
'accuracy': lambda x: random.randint(0, 6),
'communication': lambda x: random.randint(0, 6),
'cleanliness': lambda x: random.randint(0, 6),
'location': lambda x: random.randint(0, 6),
'check_in': lambda x: random.randint(0, 6),
'value': lambda x: random.randint(0, 6),
'room': lambda x: random.choice(room),
'user': lambda x: random.choice(user),
})
seeder.execute()
self.stdout.write(self.style.SUCCESS(f'{number} reviews created!'))
def handle(self, *args, **options):
number = options.get("number")
seeder = Seed.seeder()
users = user_models.User.objects.all()
rooms = room_models.Room.objects.all()
seeder.add_entity(list_models.List, number, {
"user": lambda x: random.choice(users),
})
created = seeder.execute()
cleaned = flatten(list(created.values()))
for pk in cleaned:
list_model = list_models.List.objects.get(pk=pk)
to_add = rooms[random.randint(0, 5):random.randint(6, 30)]
# this will be a querset and I want elements inside of the queryset
list_model.rooms.add(*to_add)
self.stdout.write(
self.style.SUCCESS(f"{NAME} are created successfully!"))
def seed():
seeder = Seed.seeder()
seeder.add_entity(Company, 20, {'logo': None})
seeder.add_entity(DoorDevice, 20)
seeder.execute()
users = [{'email': '*****@*****.**', 'is_staff': True, 'is_superuser': True},
{'email': '*****@*****.**', 'is_admin': True},
{'email': '*****@*****.**', 'company': Company.objects.first()},
{'email': '*****@*****.**'}]
fake = Faker()
for u in users:
us = User(**u)
us.first_name = fake.first_name()
us.last_name = fake.last_name()
us.set_password('123456')
us.save()
def handle(self, *args, **options):
number = options.get("number")
seeder = Seed.seeder()
all_users = user_models.User.objects.all()
all_rooms = room_models.Room.objects.all()
seeder.add_entity(
reservation_models.Reservation,
number,
{
"status": lambda x: random.choice(["pending", "confirmed", "canceled"]),
"guest": lambda x: random.choice(all_users),
"room": lambda x: random.choice(all_rooms),
"check_in": lambda x: datetime.now(),
"check_out": lambda x: datetime.now()
+ timedelta(days=random.randint(3, 25)),
},
)
seeder.execute()
self.stdout.write(self.style.SUCCESS(f"{number} {NAME} created"))
def handle(self, *args, **options):
number = options.get("number")
seeder = Seed.seeder()
users = user_models.User.objects.all()
rooms = room_models.Room.objects.all()[4:10]
# index 4부터 10사이의 값으로만 제한함
seeder.add_entity(list_models.List, number,
{"user": lambda x: random.choice(users)})
created = seeder.execute()
cleaned = flatten(list(created.values()))
for pk in cleaned:
list_model = list_models.List.objects.get(pk=pk)
to_add = rooms[random.randint(0, 5):random.randint(6, 30)]
list_model.rooms.add(*to_add)
# array 안에 있는 값을 원할경우 * 추가
self.stdout.write(self.style.SUCCESS(f"{number} {NAME} created!"))
def handle(self, *args, **options):
number = options.get("number", 1)
users = user_models.User.objects.all()
seeder = Seed.seeder()
seeder.add_entity(
conversation_models.Conversation,
number,
)
conversations_pk = seeder.execute()
conversations_pk = flatten(conversations_pk.values())
for conversation_pk in conversations_pk:
conversation_model = conversation_models.Conversation.objects.get(
pk=conversation_pk)
add_users = users[randint(0, 5):randint(5, 10)]
conversation_model.participants.add(*add_users)
self.stdout.write(self.style.SUCCESS(f"Create {number} {NAME}"))
def handle(self, *args, **options):
times = options.get('times')
seeder = Seed.seeder()
seeder.add_entity(
Room, times, {
'title': lambda x: random.choice(titles),
'description': lambda x: seeder.faker.text(),
'host': lambda x: random.choice(all_users),
})
created_rooms = seeder.execute()
created_clean = flatten(list(created_rooms.values()))
for pk in created_clean:
room = Room.objects.get(pk=pk)
for i in range(3, random.randint(5, 10)):
RoomPhoto.objects.create(
file=f'rooms/{random.choice(room_photo_filenames)}',
caption=seeder.faker.sentence(),
room=room)
def handle(self, *args, **options):
total = int(options.get("total"))
categories = Category.objects.all()
writers = Person.objects.filter(kind=Person.KIND_WRITER)
seeder = Seed.seeder()
seeder.add_entity(
Book,
total,
{
"title": lambda x: seeder.faker.street_name(),
"year": lambda x: seeder.faker.year(),
"rating": lambda x: randint(1, 5),
"cover_image": lambda x: f"books/{randint(1,20)}.jpg",
"category": lambda x: choice(categories),
"writer": lambda x: choice(writers),
},
)
seeder.execute()
self.stdout.write(self.style.SUCCESS(f"{total} books created!"))
def handle(self, *args, **options):
try:
number = int(options.get("number"))
self.stdout.write(self.style.SUCCESS("■ START CREATE USERS"))
seeder = Seed.seeder()
seeder.add_entity(User, number, {
"is_staff": False,
"is_superuser": False
})
seeder.execute()
self.stdout.write(
self.style.SUCCESS("■ SUCCESS CREATE ALL USERS!"))
except Exception as e:
self.stdout.write(self.style.ERROR(f"■ {e}"))
self.stdout.write(self.style.ERROR("■ FAIL CREATE USERS"))
def handle(self, *args, **options):
numbers = options.get("numbers")
seeder = Seed.seeder()
user = user_model.User.objects.all()
seeder.add_entity(
air_model.Airplane,
numbers,
{
"adult": lambda x: random.randint(0, 5),
"children": lambda x: random.randint(0, 5),
"users": lambda x: random.choice(user),
"_departure": lambda x: datetime.now # 모듈(필드)에 출발시간:지금 + timedeleta를 사용해 일 수를 더해준다.
+ timedelta(days=random.randint(2, 5)),
"_return": lambda x: datetime.now()
+ timedelta(days=random.randint(7, 20)),
},
)
seeder.execute()
self.stdout.write(self.style.SUCCESS(f"{numbers} airplane created!"))
def handle(self, *args, **options):
number = options.get("number")
seeder = Seed.seeder()
all_users = user_models.User.objects.all()
instrument = ad_models.instrumentChoice.objects.all()
seeder.add_entity(
ad_models.Advertisement,
number,
{
"student": lambda x: random.choice(all_users),
"instrument": lambda x: random.choice(instrument),
"min_fee": lambda x: random.randint(10000, 30000),
"max_fee": lambda x: random.randint(30000, 100000),
},
)
created_ads = seeder.execute()
created_clean = flatten(list(created_ads.values()))
desired_lesson_days = ad_models.LessonDay.objects.all()
lesson_type = ad_models.LessonType.objects.all()
prefer_style = ad_models.PreferStyle.objects.all()
for pk in created_clean:
advertisement = ad_models.Advertisement.objects.get(pk=pk)
for d in desired_lesson_days:
magic_number = random.randint(0, 10)
if magic_number % 2 == 0:
advertisement.desired_lesson_days.add(d)
for t in lesson_type:
magic_number = random.randint(0, 10)
if magic_number % 2 == 0:
advertisement.lesson_type.add(t)
for p in prefer_style:
magic_number = random.randint(0, 10)
if magic_number % 2 == 0:
advertisement.prefer_style.add(p)
self.stdout.write(
self.style.SUCCESS(f"{number} students' ads created!"))
def handle(self, *args, **options):
number = options.get('number')
seeder = Seed.seeder()
all_users = User.objects.all()
room_types = RoomType.objects.all()
amenities = Amenity.objects.all()
facilities = Facility.objects.all()
rules = HouseRule.objects.all()
seeder.add_entity(
Room, number, {
'name': lambda x: seeder.faker.address(),
'host': lambda x: random.choice(all_users),
'room_type': lambda x: random.choice(room_types),
'price': lambda x: random.randint(100, 10000) // 100 * 100,
'beds': lambda x: random.randint(1, 5),
'bedrooms': lambda x: random.randint(1, 5),
'baths': lambda x: random.randint(1, 5),
'guests': lambda x: random.randint(1, 10)
})
created_rooms = seeder.execute()
created_clean = flatten(list(created_rooms.values()))
for pk in created_clean:
room = Room.objects.get(pk=pk)
for i in range(3, random.randint(10, 17)):
Photo.objects.create(
caption=seeder.faker.sentence(),
room=room,
file=f'rooms_photos/{random.randint(1,31)}.webp',
)
for a in amenities:
idx = random.randint(0, 15)
if idx % 2 == 0:
room.amenities.add(a)
for f in facilities:
idx = random.randint(0, 15)
if idx % 2 == 0:
room.facilities.add(f)
for r in rules:
idx = random.randint(0, 15)
if idx % 2 == 0:
room.house_rules.add(r)
self.stdout.write(self.style.SUCCESS(f'{number} rooms are created!'))
def handle(self, *args, **options):
try:
number = int(options.get("number"))
self.stdout.write(self.style.SUCCESS("■ START CREATE REVIEWS"))
users = User.objects.all()
rooms = Room.objects.all()
for idx, room in enumerate(rooms):
seeder = Seed.seeder()
seeder.add_entity(
Review,
number,
{
"accuracy": lambda x: randint(0, 6),
"communication": lambda x: randint(0, 6),
"cleanliness": lambda x: randint(0, 6),
"location": lambda x: randint(0, 6),
"check_in": lambda x: randint(0, 6),
"value": lambda x: randint(0, 6),
"room": room,
"user": lambda x: choice(users),
},
)
self.progress_bar(
idx + 1,
len(rooms),
prefix="■ PROGRESS",
suffix="Complete",
length=40,
)
seeder.execute()
self.stdout.write(
self.style.SUCCESS("■ SUCCESS CREATE ALL REVIEWS!"))
except Exception as e:
self.stdout.write(self.style.ERROR(f"■ {e}"))
self.stdout.write(self.style.ERROR("■ FAIL CREATE REVIEWS"))
def handle(self, *args, **options):
number = options.get("number")
seeder = Seed.seeder()
all_users = user_models.User.objects.all()
resumes = resume_models.Resume.objects.all()
seeder.add_entity(
review_models.Review,
number,
{
"accuracy": lambda x: random.randint(1, 5),
"communication": lambda x: random.randint(1, 5),
"professionailsm": lambda x: random.randint(1, 5),
"kindness": lambda x: random.randint(1, 5),
"user": lambda x: random.choice(all_users),
"resume": lambda x: random.choice(resumes),
},
)
seeder.execute()
self.stdout.write(self.style.SUCCESS(f"{number} reviews created!"))
def handle(self, *args, **options):
number = options.get("number")
seeder = Seed.seeder()
rooms = Room.objects.all()
users = User.objects.all()
seeder.add_entity(
List,
number,
{
"user": lambda x: random.choice(users),
},
)
creat_rooms = seeder.execute()
cleaned = flatten(list(creat_rooms.values()))
for pk in cleaned:
list_model = List.objects.get(pk=pk)
to_add = rooms[random.randint(0, 5):random.randint(6, 10)]
list_model.rooms.add(*to_add)
self.stdout.write(self.style.SUCCESS(f"{number} Lists created"))
def handle(self, *args, **options):
users = get_user_model().objects.all()
rooms = Room.objects.all()
number = options.get("number")
seeder = Seed.seeder()
seeder.add_entity(
List,
number,
{
"user": lambda x: random.choice(users),
"name": lambda x: seeder.faker.name(),
},
)
new_lists = seeder.execute()
list_pk_list = flatten(new_lists.values())
for list_pk in list_pk_list:
new_list = List.objects.get(pk=list_pk)
room_in_list = random.sample(list(rooms), k=random.randint(3, 8))
new_list.rooms.add(*room_in_list)
print(f"{number}개의 리스트를 만들었습니다.")
def handle_app_config(self, app_config, **options):
if app_config.models_module is None:
raise SeederCommandError('You must provide an app to seed')
try:
number = int(options['number'])
except ValueError:
raise SeederCommandError('The value of --number must be an integer')
seeder = Seed.seeder()
# don't diplay warnings about non-timezone aware datetimes
import warnings
warnings.showwarning = lambda *x: None
for model in app_config.get_models():
seeder.add_entity(model, number)
print('Seeding %i %ss' % (number, model.__name__))
pks = seeder.execute()
print(pks)
import os
import django
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'web.settings')
django.setup()
from django_seed import Seed
from django.contrib.auth.models import User
from face_matcher.models import Upload
seeder = Seed.seeder()
seeder.add_entity(User, 5)
seeder.add_entity(Upload, 10, {
'url': lambda x: 'http://lorempixel.com/400/200/',
})
inserted_pks = seeder.execute()
