From fa133647618bf4afa2ed63f91222bacccd778b37 Mon Sep 17 00:00:00 2001 From: Kr4ter <111365873+UdaiBatta@users.noreply.github.com> Date: Tue, 18 Nov 2025 17:43:22 +0530 Subject: [PATCH] Refactor fake data generation for core models Refactor factories for generating fake core data and improve data generation logic. --- scripts/generate_fake_core_data.py | 137 ++++++++++++----------------- 1 file changed, 58 insertions(+), 79 deletions(-) diff --git a/scripts/generate_fake_core_data.py b/scripts/generate_fake_core_data.py index b76a3681..3e41216f 100644 --- a/scripts/generate_fake_core_data.py +++ b/scripts/generate_fake_core_data.py @@ -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!")