Skip to content

Refactor fake data generation for core models #23

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
UdaiBatta wants to merge 1 commit into
base: main
Choose a base branch
from
Open

Refactor fake data generation for core models #23

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
137 changes: 58 additions & 79 deletions scripts/generate_fake_core_data.py
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,127 +1,106 @@
import os
import django
import random
from random import choice
from typing import List
from django.utils import timezone
from faker import Faker
from factory.django import DjangoModelFactory
from factory import SubFactory, LazyAttribute, Iterator, LazyFunction
from core.models import ActivityLog, NewsAndEvents, Session, Semester, SEMESTER, POST

# Set up Django environment
# Django setup
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
django.setup()

from core.models import ActivityLog, NewsAndEvents, Session, Semester, SEMESTER, POST

fake = Faker()


# ------------------ News & Events ------------------ #
class NewsAndEventsFactory(DjangoModelFactory):
"""
Factory for creating NewsAndEvents instances.

Attributes:
title (str): The generated title for the news or event.
summary (str): The generated summary.
posted_as (str): The type of the post, either 'News' or 'Event'.
updated_date (datetime): The generated date and time of update.
upload_time (datetime): The generated date and time of upload.
"""

class Meta:
model = NewsAndEvents

title: str = LazyAttribute(lambda x: fake.sentence(nb_words=4))
summary: str = LazyAttribute(lambda x: fake.paragraph(nb_sentences=3))
posted_as: str = LazyFunction(
lambda: fake.random_element(elements=[choice[0] for choice in POST])
)
# updated_date: timezone.datetime = fake.date_time_this_year()
# upload_time: timezone.datetime = fake.date_time_this_year()
title = LazyAttribute(lambda _: fake.sentence(nb_words=4))
summary = LazyAttribute(lambda _: fake.paragraph(nb_sentences=3))
posted_as = LazyFunction(lambda: fake.random_element([c[0] for c in POST]))
updated_date = LazyFunction(fake.date_time_this_year)
upload_time = LazyFunction(fake.date_time_this_year)


# ------------------ Session ------------------ #
class SessionFactory(DjangoModelFactory):
"""
Factory for creating Session instances.

Attributes:
session (str): The generated session name.
is_current_session (bool): Flag indicating if the session is current.
next_session_begins (date): The date when the next session begins.
"""

class Meta:
model = Session

session: str = LazyAttribute(lambda x: str(fake.random_int(min=2020, max=2030)))
is_current_session: bool = fake.boolean(chance_of_getting_true=50)
next_session_begins = LazyAttribute(lambda x: fake.future_datetime())
session = LazyFunction(lambda: f"{fake.random_int(2018, 2030)}/{fake.random_int(2019, 2031)}")
is_current_session = LazyFunction(lambda: fake.boolean(50))
next_session_begins = LazyFunction(fake.future_date)

@classmethod
def _create(cls, model_class, *args, **kwargs):
obj, created = Session.objects.get_or_create(
session=kwargs["session"],
defaults=kwargs
)
return obj

class SemesterFactory(DjangoModelFactory):
"""
Factory for creating Semester instances.

Attributes:
semester (str): The generated semester name.
is_current_semester (bool): Flag indicating if the semester is current.
session (Session): The associated session.
next_semester_begins (date): The date when the next semester begins.
"""

# ------------------ Semester ------------------ #
class SemesterFactory(DjangoModelFactory):
class Meta:
model = Semester

semester: str = fake.random_element(elements=[choice[0] for choice in SEMESTER])
is_current_semester: bool = fake.boolean(chance_of_getting_true=50)
session: Session = SubFactory(SessionFactory)
next_semester_begins = LazyAttribute(lambda x: fake.future_datetime())
semester = LazyFunction(lambda: fake.random_element([c[0] for c in SEMESTER]))
is_current_semester = LazyFunction(lambda: fake.boolean(50))
session = SubFactory(SessionFactory)
next_semester_begins = LazyFunction(fake.future_datetime)

@classmethod
def _create(cls, model_class, *args, **kwargs):
obj, created = Semester.objects.get_or_create(
semester=kwargs["semester"],
session=kwargs["session"],
defaults=kwargs
)
return obj

class ActivityLogFactory(DjangoModelFactory):
"""
Factory for creating ActivityLog instances.

Attributes:
message (str): The generated log message.
"""

# ------------------ Activity Logs ------------------ #
class ActivityLogFactory(DjangoModelFactory):
class Meta:
model = ActivityLog

message: str = LazyAttribute(lambda x: fake.text())
message = LazyAttribute(lambda _: fake.text())


# ------------------ Main Generator ------------------ #
def generate_fake_core_data(
num_news_and_events: int,
num_sessions: int,
num_semesters: int,
num_activity_logs: int,
) -> None:
"""
Generate fake data for core models: NewsAndEvents, Session, Semester, and ActivityLog.

Args:
num_news_and_events (int): Number of NewsAndEvents instances to generate.
num_sessions (int): Number of Session instances to generate.
num_semesters (int): Number of Semester instances to generate.
num_activity_logs (int): Number of ActivityLog instances to generate.
"""
# Generate fake NewsAndEvents instances
news_and_events: List[NewsAndEvents] = NewsAndEventsFactory.create_batch(
num_news_and_events
)
print(f"Generated {num_news_and_events} NewsAndEvents instances.")
):
news = NewsAndEventsFactory.create_batch(num_news_and_events)
print(f"Generated {len(news)} News & Events")

sessions = SessionFactory.create_batch(num_sessions)
print(f"Generated {len(sessions)} Sessions")

semesters = SemesterFactory.create_batch(num_semesters)
print(f"Generated {len(semesters)} Semesters")

# Generate fake Session instances
sessions: List[Session] = SessionFactory.create_batch(num_sessions)
print(f"Generated {num_sessions} Session instances.")
logs = ActivityLogFactory.create_batch(num_activity_logs)
print(f"Generated {len(logs)} Activity Logs")

# Generate fake Semester instances
semesters: List[Semester] = SemesterFactory.create_batch(num_semesters)
print(f"Generated {num_semesters} Semester instances.")

# Generate fake ActivityLog instances
activity_logs: List[ActivityLog] = ActivityLogFactory.create_batch(
num_activity_logs
# ------------------ Required by runscript ------------------ #
def run():
generate_fake_core_data(
num_news_and_events=10,
num_sessions=5,
num_semesters=5,
num_activity_logs=30,
)
print(f"Generated {num_activity_logs} ActivityLog instances.")
print("Fake CORE data inserted successfully!")