Changes to endpoints so they allow to only get context and then the exercises as well as tidying up a bit

app/services/impl/exam/reading/__init__.py

@@ -0,0 +1,131 @@
+from logging import getLogger
+
+from fastapi import UploadFile
+
+from app.configs.constants import GPTModels, FieldsAndExercises, TemperatureSettings
+from app.dtos.reading import ReadingDTO
+from app.helpers import ExercisesHelper
+from app.services.abc import IReadingService, ILLMService
+from .fill_blanks import FillBlanks
+from .idea_match import IdeaMatch
+from .paragraph_match import ParagraphMatch
+from .true_false import TrueFalse
+from .import_reading import ImportReadingModule
+from .write_blanks import WriteBlanks
+
+
+class ReadingService(IReadingService):
+
+    def __init__(self, llm: ILLMService):
+        self._llm = llm
+        self._fill_blanks = FillBlanks(llm)
+        self._idea_match = IdeaMatch(llm)
+        self._paragraph_match = ParagraphMatch(llm)
+        self._true_false = TrueFalse(llm)
+        self._write_blanks = WriteBlanks(llm)
+        self._logger = getLogger(__name__)
+        self._import = ImportReadingModule(llm)
+
+    async def import_exam(self, exercises: UploadFile, solutions: UploadFile = None):
+        return await self._import.import_from_file(exercises, solutions)
+
+    async def generate_reading_passage(self, part: int, topic: str, word_count: int = 800):
+        part_system_message = {
+            "1": 'The generated text should be fairly easy to understand and have multiple paragraphs.',
+            "2": 'The generated text should be fairly hard to understand and have multiple paragraphs.',
+            "3": (
+                'The generated text should be very hard to understand and include different points, theories, '
+                'subtle differences of opinions from people, correctly sourced to the person who said it, '
+                'over the specified topic and have multiple paragraphs.'
+            )
+        }
+
+        messages = [
+            {
+                "role": "system",
+                "content": (
+                    'You are a helpful assistant designed to output JSON on this format: '
+                    '{"title": "title of the text", "text": "generated text"}')
+            },
+            {
+                "role": "user",
+                "content": (
+                    f'Generate an extensive text for IELTS Reading Passage {part}, of at least {word_count} words, '
+                    f'on the topic of "{topic}". The passage should offer a substantial amount of '
+                    'information, analysis, or narrative relevant to the chosen subject matter. This text '
+                    'passage aims to serve as the primary reading section of an IELTS test, providing an '
+                    'in-depth and comprehensive exploration of the topic. Make sure that the generated text '
+                    'does not contain forbidden subjects in muslim countries.'
+                )
+            },
+            {
+                "role": "system",
+                "content": part_system_message[str(part)]
+            }
+        ]
+
+        if part == 3:
+            messages.append({
+                "role": "user",
+                "content": "Use real text excerpts on your generated passage and cite the sources."
+            })
+
+        return await self._llm.prediction(
+            GPTModels.GPT_4_O,
+            messages,
+            FieldsAndExercises.GEN_TEXT_FIELDS,
+            TemperatureSettings.GEN_QUESTION_TEMPERATURE
+        )
+
+    async def generate_reading_exercises(self, dto: ReadingDTO):
+        exercises = []
+        start_id = 1
+        for req_exercise in dto.exercises:
+            if req_exercise.type == "fillBlanks":
+                question = await self._fill_blanks.gen_summary_fill_blanks_exercise(
+                    dto.text, req_exercise.quantity, start_id, dto.difficulty, req_exercise.num_random_words
+                )
+                exercises.append(question)
+                self._logger.info(f"Added fill blanks: {question}")
+
+            elif req_exercise.type == "trueFalse":
+                question = await self._true_false.gen_true_false_not_given_exercise(
+                    dto.text, req_exercise.quantity, start_id, dto.difficulty
+                )
+                exercises.append(question)
+                self._logger.info(f"Added trueFalse: {question}")
+
+            elif req_exercise.type == "writeBlanks":
+                question = await self._write_blanks.gen_write_blanks_exercise(
+                    dto.text, req_exercise.quantity, start_id, dto.difficulty, req_exercise.max_words
+                )
+
+                if ExercisesHelper.answer_word_limit_ok(question):
+                    exercises.append(question)
+                    self._logger.info(f"Added write blanks: {question}")
+                else:
+                    exercises.append({})
+                    self._logger.info("Did not add write blanks because it did not respect word limit")
+
+            elif req_exercise.type == "paragraphMatch":
+
+                question = await self._paragraph_match.gen_paragraph_match_exercise(
+                    dto.text, req_exercise.quantity, start_id
+                )
+                exercises.append(question)
+                self._logger.info(f"Added paragraph match: {question}")
+
+            elif req_exercise.type == "ideaMatch":
+
+                question = await self._idea_match.gen_idea_match_exercise(
+                    dto.text, req_exercise.quantity, start_id
+                )
+                question["variant"] = "ideaMatch"
+                exercises.append(question)
+                self._logger.info(f"Added idea match: {question}")
+
+            start_id = start_id + req_exercise.quantity
+
+        return {
+            "exercises": exercises
+        }