src.moodle_to_vikwikiquiz.quiz_helpers.get_grading_of_question() - Code Metrics - Inspection of "Merge branch 'dev'" - gy-mate/moodle-to-vikwikiquiz - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — main (462934)

by Máté

created 2024-06-09 03:57 UTC

src.moodle_to_vikwikiquiz.quiz_helpers.get_grading_of_question() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines	15
Code Lines	12

Duplication

Lines	15
Ratio	100 %

Importance

Changes

Metric	Value
eloc	12
dl	15
loc	15
rs	9.8
c	0
b	0
f	0
cc	2
nop	1

import os
import re

from bs4 import Tag

# future: report false positive to JetBrains developers
# noinspection PyPackages
from .question import Question  # type: ignore

# noinspection PyPackages
from .question_types import QuestionType  # type: ignore


def get_question_type(question: Tag) -> QuestionType:
    if question.find("input", type="radio"):
        return QuestionType.SingleChoice
    elif question.find("input", type="checkbox"):
        return QuestionType.MultipleChoice
    else:
        raise NotImplementedError("Question type not implemented.")


def get_grading_of_question(question: Tag) -> tuple[bool, float | None, float]:
    correctly_answered: bool

    found_tag = question.find("div", class_="grade")
    assert isinstance(found_tag, Tag)

    grading_text = found_tag.text
    numbers = re.findall(r"\d+\.\d+", grading_text)
    grade: float | None = None
    match len(numbers):
        case 1:
            maximum_points = float(numbers[0])
        case 2:
            grade = float(numbers[0])
            maximum_points = float(numbers[1])
        case _:
            raise NotImplementedError
    if grade == maximum_points:
        correctly_answered = True
    else:
        correctly_answered = False
    return correctly_answered, grade, maximum_points


def complete_correct_answers(
    answer_texts: list[str],
    correct_answers: list[int],
    grade: float,
    maximum_points: float,
    question_text: str,
    question_type: QuestionType,
    file_name: str,
) -> None:
    if len(correct_answers) == len(answer_texts) - 1:
        correct_answers.append(
            get_id_of_only_remaining_answer(answer_texts, correct_answers)
        )
        return
    print(f"File: {file_name}")
    print(f"Question: '{question_text}'")
    match len(correct_answers):
        case 0:
            print("\nI couldn't determine any correct answers for sure.", end=" ")
        case 1:
            print(
                f"\nI see that answer #{correct_answers[0]} is correct, "
                f"but there might be additional correct answers because you only got {grade:g} points out of {maximum_points:g}.",
                end=" ",
            )
        case _:
            print(
                f"\nI see that answers {correct_answers} are correct, "
                f"but this list may be incomplete because you only got {grade:g} points out of {maximum_points:g}.",
                end=" ",
            )
    print(f"The possible answers are:", end="\n\n")
    assert isinstance(answer_texts, list)
    # report false positive to mypy developers
    for j, answer in enumerate(answer_texts):  # type: ignore
        print(f"#{j + 1}\t{answer}")
    print()
    while True:
        get_missing_correct_answers(answer_texts, correct_answers, question_type)
        if correct_answers:
            break
        print("Error: no correct answers were provided!", end="\n\n")


def get_id_of_only_remaining_answer(
    answer_texts: list[str], correct_answers: list[int]
) -> int:
    for i, answer in enumerate(answer_texts, 1):
        if i not in correct_answers:
            return i
    raise NotImplementedError


def get_missing_correct_answers(
    answer_texts: list[str], correct_answers: list[int], question_type: QuestionType
) -> None:
    while len(correct_answers) < len(answer_texts):
        additional_correct_answer = input(
            f"Please enter a missing correct answer (if there is any remaining) then press Enter: "
        )
        if additional_correct_answer == "":
            break
        elif not additional_correct_answer.isdigit():
            print("Error: an integer was expected!", end="\n\n")
            continue
        elif int(additional_correct_answer) - 1 not in range(len(answer_texts)):
            print(
                "Error: the number is out of the range of possible answers!", end="\n\n"
            )
            continue
        elif int(additional_correct_answer) in correct_answers:
            print(
                "Error: this answer is already in the list of correct answers!",
                end="\n\n",
            )
            continue
        correct_answers.append(int(additional_correct_answer))
        if question_type == QuestionType.SingleChoice:
            break


def get_answers(
    question: Tag, grade: float, maximum_points: float
) -> tuple[list[str], list[int]]:
    answers = question.find("div", class_="answer")
    assert isinstance(answers, Tag)
    answer_texts: list[str] = []
    correct_answers: list[int] = []
    i = 1
    for answer in answers:
        if not isinstance(answer, Tag):
            continue
        found_tag = answer.find("div", class_="ml-1")
        assert isinstance(found_tag, Tag)
        answer_text = found_tag.text.rstrip(".\n")
        answer_text = format_latex_as_wikitext(answer_text)
        answer_texts.append(answer_text)
        if answer_is_correct(answer, grade, maximum_points):
            correct_answers.append(i)
        i += 1
    return answer_texts, correct_answers


def answer_is_correct(answer: Tag, grade: float, maximum_points: float) -> bool:
    if "correct" in answer["class"]:
        return True
    elif grade == maximum_points:
        answer_input_element = answer.find("input")
        assert isinstance(answer_input_element, Tag)
        if answer_input_element.has_attr("checked"):
            return True
    return False


def get_question_text(question: Tag) -> str:
    found_tag = question.find("div", class_="qtext")
    assert isinstance(found_tag, Tag)
    text = re.sub(r"\n", " ", found_tag.text)
    return text.rstrip()


def format_latex_as_wikitext(text: str) -> str:
    text = re.sub(r"^(\\)?\\\(( )?(( )?\\(?=\\))?", "<math>", text)
    text = re.sub(r"( \\)?\\\)( )?$", "</math>", text)
    return text


def question_already_exists(existing_question: Question, question_text: str) -> bool:
    return existing_question.text == question_text


def add_answers_to_existing_question(
    answer_texts: list[str], correct_answers: list[int], existing_question: Question
) -> None:
    # report false positive to mypy developers
    for k, answer in enumerate(answer_texts):  # type: ignore
        if answer not in existing_question.answers:
            assert isinstance(answer, str)
            existing_question.answers.append(answer)
            if k + 1 in correct_answers:
                existing_question.correct_answers.add(len(existing_question.answers))


def get_if_has_illustration(question: Tag) -> bool:
    if question.find("img", class_="img-responsive"):
        return True
    elif question.find("img", role="presentation"):
        return True
    else:
        return False


def clear_terminal():
    os.system("clear||cls")


1			import os
2			import re
3
4			from bs4 import Tag
5
6			# future: report false positive to JetBrains developers
7			# noinspection PyPackages
8			from .question import Question # type: ignore
9
10			# noinspection PyPackages
11			from .question_types import QuestionType # type: ignore
12
13
14			def get_question_type(question: Tag) -> QuestionType:
15			if question.find("input", type="radio"):
16			return QuestionType.SingleChoice
17			elif question.find("input", type="checkbox"):
18			return QuestionType.MultipleChoice
19			else:
20			raise NotImplementedError("Question type not implemented.")
21
22
23			def get_grading_of_question(question: Tag) -> tuple[bool, float \| None, float]:
24			correctly_answered: bool
25
26			found_tag = question.find("div", class_="grade")
27			assert isinstance(found_tag, Tag)
28
29			grading_text = found_tag.text
30			numbers = re.findall(r"\d+\.\d+", grading_text)
31			grade: float \| None = None
32			match len(numbers):
33			case 1:
34			maximum_points = float(numbers[0])
35			case 2:
36			grade = float(numbers[0])
37			maximum_points = float(numbers[1])
38			case _:
39			raise NotImplementedError
40			if grade == maximum_points:
41			correctly_answered = True
42			else:
43			correctly_answered = False
44			return correctly_answered, grade, maximum_points
45
46
47			def complete_correct_answers(
48			answer_texts: list[str],
49			correct_answers: list[int],
50			grade: float,
51			maximum_points: float,
52			question_text: str,
53			question_type: QuestionType,
54			file_name: str,
55			) -> None:
56			if len(correct_answers) == len(answer_texts) - 1:
57			correct_answers.append(
58			get_id_of_only_remaining_answer(answer_texts, correct_answers)
59			)
60			return
61			print(f"File: {file_name}")
62			print(f"Question: '{question_text}'")
63			match len(correct_answers):
64			case 0:
65			print("\nI couldn't determine any correct answers for sure.", end=" ")
66			case 1:
67			print(
68			f"\nI see that answer #{correct_answers[0]} is correct, "
69			f"but there might be additional correct answers because you only got {grade:g} points out of {maximum_points:g}.",
70			end=" ",
71			)
72			case _:
73			print(
74			f"\nI see that answers {correct_answers} are correct, "
75			f"but this list may be incomplete because you only got {grade:g} points out of {maximum_points:g}.",
76			end=" ",
77			)
78			print(f"The possible answers are:", end="\n\n")
79			assert isinstance(answer_texts, list)
80			# report false positive to mypy developers
81			for j, answer in enumerate(answer_texts): # type: ignore
82			print(f"#{j + 1}\t{answer}")
83			print()
84			while True:
85			get_missing_correct_answers(answer_texts, correct_answers, question_type)
86			if correct_answers:
87			break
88			print("Error: no correct answers were provided!", end="\n\n")
89
90
91			def get_id_of_only_remaining_answer(
92			answer_texts: list[str], correct_answers: list[int]
93			) -> int:
94			for i, answer in enumerate(answer_texts, 1):
95			if i not in correct_answers:
96			return i
97			raise NotImplementedError
98
99
100			def get_missing_correct_answers(
101			answer_texts: list[str], correct_answers: list[int], question_type: QuestionType
102			) -> None:
103			while len(correct_answers) < len(answer_texts):
104			additional_correct_answer = input(
105			f"Please enter a missing correct answer (if there is any remaining) then press Enter: "
106			)
107			if additional_correct_answer == "":
108			break
109			elif not additional_correct_answer.isdigit():
110			print("Error: an integer was expected!", end="\n\n")
111			continue
112			elif int(additional_correct_answer) - 1 not in range(len(answer_texts)):
113			print(
114			"Error: the number is out of the range of possible answers!", end="\n\n"
115			)
116			continue
117			elif int(additional_correct_answer) in correct_answers:
118			print(
119			"Error: this answer is already in the list of correct answers!",
120			end="\n\n",
121			)
122			continue
123			correct_answers.append(int(additional_correct_answer))
124			if question_type == QuestionType.SingleChoice:
125			break
126
127
128			def get_answers(
129			question: Tag, grade: float, maximum_points: float
130			) -> tuple[list[str], list[int]]:
131			answers = question.find("div", class_="answer")
132			assert isinstance(answers, Tag)
133			answer_texts: list[str] = []
134			correct_answers: list[int] = []
135			i = 1
136			for answer in answers:
137			if not isinstance(answer, Tag):
138			continue
139			found_tag = answer.find("div", class_="ml-1")
140			assert isinstance(found_tag, Tag)
141			answer_text = found_tag.text.rstrip(".\n")
142			answer_text = format_latex_as_wikitext(answer_text)
143			answer_texts.append(answer_text)
144			if answer_is_correct(answer, grade, maximum_points):
145			correct_answers.append(i)
146			i += 1
147			return answer_texts, correct_answers
148
149
150			def answer_is_correct(answer: Tag, grade: float, maximum_points: float) -> bool:
151			if "correct" in answer["class"]:
152			return True
153			elif grade == maximum_points:
154			answer_input_element = answer.find("input")
155			assert isinstance(answer_input_element, Tag)
156			if answer_input_element.has_attr("checked"):
157			return True
158			return False
159
160
161			def get_question_text(question: Tag) -> str:
162			found_tag = question.find("div", class_="qtext")
163			assert isinstance(found_tag, Tag)
164			text = re.sub(r"\n", " ", found_tag.text)
165			return text.rstrip()
166
167
168			def format_latex_as_wikitext(text: str) -> str:
169			text = re.sub(r"^(\\)?\\\(( )?(( )?\\(?=\\))?", "<math>", text)
170			text = re.sub(r"( \\)?\\\)( )?$", "</math>", text)
171			return text
172
173
174			def question_already_exists(existing_question: Question, question_text: str) -> bool:
175			return existing_question.text == question_text
176
177
178			def add_answers_to_existing_question(
179			answer_texts: list[str], correct_answers: list[int], existing_question: Question
180			) -> None:
181			# report false positive to mypy developers
182			for k, answer in enumerate(answer_texts): # type: ignore
183			if answer not in existing_question.answers:
184			assert isinstance(answer, str)
185			existing_question.answers.append(answer)
186			if k + 1 in correct_answers:
187			existing_question.correct_answers.add(len(existing_question.answers))
188
189
190			def get_if_has_illustration(question: Tag) -> bool:
191			if question.find("img", class_="img-responsive"):
192			return True
193			elif question.find("img", role="presentation"):
194			return True
195			else:
196			return False
197
198
199			def clear_terminal():
200			os.system("clear\|\|cls")
201

gy-mate / moodle-to-vikwikiquiz

Branch — main (462934)

src.moodle_to_vikwikiquiz.quiz_helpers.get_grading_of_question() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like