Calculate results from grades panel & previous gpa and display them

Author: zefr0x

moadaly/common_conversions.py

@@ -1,4 +1,41 @@
 """Some common conversions."""
+from gettext import gettext as _
+
+
+grades = [
+    _("Undefined"),
+    _("A+"),
+    _("A"),
+    _("B+"),
+    _("B"),
+    _("C+"),
+    _("C"),
+    _("D+"),
+    _("D"),
+    _("F"),
+]
+
+
+def get_grade_from_gpa(gpa: float) -> str:
+    """Convert the gpa to a grade."""
+    if gpa >= 4.75:
+        return grades[1]
+    elif gpa >= 4.5:
+        return grades[2]
+    elif gpa >= 4.0:
+        return grades[3]
+    elif gpa >= 3.5:
+        return grades[4]
+    elif gpa >= 3.0:
+        return grades[5]
+    elif gpa >= 2.5:
+        return grades[6]
+    elif gpa >= 2.0:
+        return grades[7]
+    elif gpa >= 1.0:
+        return grades[8]
+    else:
+        return grades[9]
 
 
 def get_grade_from_score(score: float) -> int:

moadaly/ui/grades_panel.py

@@ -10,12 +10,17 @@
 class GradesPanel(QtWidgets.QWidget):
     """A panel to display semesters, and to handle the addition of new semesters."""
 
+    panel_calculation_changed = QtCore.Signal()
+
     def __init__(self):
         """Initialize base components of the panel."""
         super().__init__()
 
         self.semesters = []
 
+        self.total_points = 0.0
+        self.total_credits = 0
+
         self.layout = QtWidgets.QVBoxLayout(self)
 
         self.scroll_area = QtWidgets.QScrollArea()
@@ -38,16 +43,31 @@ def __init__(self):
         self.scroll_area.setFixedHeight(500)
         self.scroll_area.setWidget(self)
 
+    def calculate_panel(self) -> None:
+        """Calculate the sum of the semesters points and credit units."""
+        self.total_points = 0.0
+        self.total_credits = 0
+
+        for semester in self.semesters:
+            self.total_points += semester.total_points
+            self.total_credits += semester.total_credits
+
+        # Send a signal with the new points and credits to be displayed.
+        self.panel_calculation_changed.emit()
+
     def add_new_semester(self):
         """Add new semester widget to the grades panel."""
-        widget = SemesterWidget(self)
-        self.semesters.append(widget)
-        self.layout.insertWidget(len(self.semesters) - 1, widget)
+        semester = SemesterWidget(self)
+        semester.semester_calculation_updated.connect(self.calculate_panel)
+        self.semesters.append(semester)
+        self.layout.insertWidget(len(self.semesters) - 1, semester)
 
 
 class SemesterWidget(QtWidgets.QWidget):
     """A semester that contain a list of corses, to be added to the grades panel."""
 
+    semester_calculation_updated = QtCore.Signal()
+
     def __init__(self, parent_panel):
         """Initialize a new semester and it's base components."""
         super().__init__()
@@ -56,6 +76,9 @@ def __init__(self, parent_panel):
         self.semester_id: str = uuid4().hex
         self.courses = []
 
+        self.total_points = 0.0
+        self.total_credits = 0
+
         self.layout = QtWidgets.QVBoxLayout(self)
 
         # Create the semester title bar.
@@ -117,6 +140,19 @@ def __init__(self, parent_panel):
         add_course_button.clicked.connect(self.add_new_course)
         self.layout.addWidget(add_course_button)
 
+    def calculate_semester(self) -> None:
+        """Calculate the sum of points and the sum of credits in the semester."""
+        self.total_points = 0.0
+        self.total_credits = 0
+
+        # TODO Display the semester GPA, credit units and points in the GUI.
+        for course in self.courses:
+            self.total_points += course.points.value()
+            self.total_credits += course.credit.value()
+
+        # Send signal to recalculate panel.
+        self.semester_calculation_updated.emit()
+
     def delete_semester(self):
         """Remove a specified semester from the grades panel."""
         semester_index = self.parent_panel.semesters.index(self)
@@ -126,16 +162,23 @@ def delete_semester(self):
         for i in range(semester_index, len(self.parent_panel.semesters)):
             self.parent_panel.semesters[i].title.setText(_("Semester %d") % (i + 1))
 
+        # Send signal to recalculate panel.
+        # FIXME When it is the last semester in the panel, results will not be updated.
+        self.semester_calculation_updated.emit()
+
     def add_new_course(self):
         """Add new course widget to the semester."""
-        widget = CourseWidget(self)
-        self.courses.append(widget)
-        self.layout.insertWidget(len(self.courses) + 1, widget)
+        course = CourseWidget(self)
+        course.points_changed.connect(self.calculate_semester)
+        self.courses.append(course)
+        self.layout.insertWidget(len(self.courses) + 1, course)
 
 
 class CourseWidget(QtWidgets.QWidget):
     """A course that can be added inside a semester."""
 
+    points_changed = QtCore.Signal()
+
     def __init__(self, parent_semester):
         """Initialize a new course and it's components."""
         super().__init__()
@@ -172,28 +215,15 @@ def __init__(self, parent_semester):
         self.layout.addWidget(self.credit)
 
         self.grade = QtWidgets.QComboBox()
-        self.grade.addItems(
-            [
-                _("Undefined"),
-                _("A+"),
-                _("A"),
-                _("B+"),
-                _("B"),
-                _("C+"),
-                _("C"),
-                _("D+"),
-                _("D"),
-                _("F"),
-            ]
-        )
+        self.grade.addItems(common_conversions.grades)
         self.grade.currentIndexChanged.connect(self.grade_changed)
         self.layout.addWidget(self.grade)
 
         self.points = QtWidgets.QDoubleSpinBox()
         self.points.setReadOnly(True)
         self.points.setFocusPolicy(QtCore.Qt.FocusPolicy.NoFocus)
         self.points.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
-        self.points.setMaximum(1000)
+        self.points.setMaximum(10000)
         self.layout.addWidget(self.points)
 
         self.delete_course_button = QtWidgets.QPushButton(
@@ -210,6 +240,9 @@ def update_points(self) -> None:
             * self.credit.value()
         )
 
+        # Send signal to recalculate semester.
+        self.points_changed.emit()
+
     def score_changed(self) -> None:
         """Change the grade when the score is changed."""
         try:
@@ -245,3 +278,7 @@ def delete_course(self):
 
         for i in range(course_index, len(self.parent_semester.courses)):
             self.parent_semester.courses[i].title.setText(_("Course %d") % (i + 1))
+
+        # Send signal to recalculate semester.
+        # FIXME When it is the last course in the semester, results will not be updated.
+        self.points_changed.emit()

moadaly/ui/main.py

@@ -36,15 +36,19 @@ def __init__(self):
 
         # Create main window widgets.
         self.result_box = result_box.ResultBox()
-        self.previous_gpa_box = previous_cgpa_box.PreviousCGPABox()
+        self.previous_cgpa_box = previous_cgpa_box.PreviousCGPABox()
         self.calculation_system_box = (
             calculation_system_options_box.CalculationSystemBox()
         )
         self.grades_panel = grades_panel.GradesPanel()
 
+        # Listen to signals when the calculation is updated.
+        self.grades_panel.panel_calculation_changed.connect(self.update_results)
+        self.previous_cgpa_box.previous_points_changed.connect(self.update_results)
+
         # Add main components to the main window layout.
         top_panel_layout.addWidget(self.result_box)
-        top_panel_layout.addWidget(self.previous_gpa_box)
+        top_panel_layout.addWidget(self.previous_cgpa_box)
         top_panel_layout.addWidget(self.calculation_system_box)
         bottom_panel_layout.addWidget(self.grades_panel.scroll_area)
 
@@ -58,6 +62,16 @@ def __init__(self):
 
         self.create_menu_bar()
 
+    def update_results(self):
+        """Update the results in the result widget."""
+        # Get the results from the grades panel and the previous gpa widget.
+        self.result_box.display_new_calculation(
+            self.grades_panel.total_points
+            + self.previous_cgpa_box.previous_points.value(),
+            self.grades_panel.total_credits
+            + self.previous_cgpa_box.previous_credit.value(),
+        )
+
     def create_menu_bar(self):
         """Create all the menu bar components and actions."""
         self.menu_bar = self.menuBar()

moadaly/ui/previous_cgpa_box.py

@@ -7,6 +7,8 @@
 class PreviousCGPABox(QtWidgets.QWidget):
     """A Group Box where you can specify a previous CGPA, to add it to the calculation."""
 
+    previous_points_changed = QtCore.Signal()
+
     def __init__(self):
         """Initialize components of the previous CGPA widget."""
         super().__init__()
@@ -42,6 +44,7 @@ def __init__(self):
         self.previous_points.setReadOnly(True)
         self.previous_points.setFocusPolicy(QtCore.Qt.FocusPolicy.NoFocus)
         self.previous_points.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
+        self.previous_points.setMaximum(10000)
         self.previous_points.setDecimals(3)
         group_box_layout.addRow(
             QtWidgets.QLabel(_("Previous Points")), self.previous_points
@@ -52,3 +55,5 @@ def update_previous_points(self) -> None:
         self.previous_points.setValue(
             self.previous_cgpa.value() * self.previous_credit.value()
         )
+
+        self.previous_points_changed.emit()

moadaly/ui/result_box.py

@@ -3,6 +3,8 @@
 
 from PySide6 import QtCore, QtWidgets
 
+from .. import common_conversions
+
 
 class ResultBox(QtWidgets.QWidget):
     """A Group Box where the results are displayed, such as, GPA, grade, total hours and points."""
@@ -30,16 +32,18 @@ def __init__(self):
         group_box_layout.addRow(QtWidgets.QLabel(_("CGPA:")), self.result_gpa)
 
         # Result hours.
-        self.result_hours = QtWidgets.QSpinBox()
-        self.result_hours.setReadOnly(True)
-        self.result_hours.setFocusPolicy(QtCore.Qt.FocusPolicy.NoFocus)
-        self.result_hours.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
-        self.result_hours.setStyleSheet(
+        self.result_credits = QtWidgets.QSpinBox()
+        self.result_credits.setReadOnly(True)
+        self.result_credits.setFocusPolicy(QtCore.Qt.FocusPolicy.NoFocus)
+        self.result_credits.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons)
+        self.result_credits.setStyleSheet(
             """
         font: bold;
         """
         )
-        group_box_layout.addRow(QtWidgets.QLabel(_("Hours:")), self.result_hours)
+        group_box_layout.addRow(
+            QtWidgets.QLabel(_("Credit Units:")), self.result_credits
+        )
 
         # Result points.
         self.result_points = QtWidgets.QDoubleSpinBox()
@@ -66,3 +70,14 @@ def __init__(self):
         group_box_layout.addRow(QtWidgets.QLabel(_("Grade:")), self.result_grade)
 
         group_box.setLayout(group_box_layout)
+
+    def display_new_calculation(self, points, credits) -> None:
+        """Display the new results."""
+        if credits:
+            cgpa = points / credits
+            self.result_gpa.setValue(cgpa)
+            self.result_credits.setValue(credits)
+            self.result_points.setValue(points)
+            # FIXME The grade is displayed "A+" while it should be "A"
+            # when the points are exactly 4.75 and the credits are 1.
+            self.result_grade.setText(common_conversions.get_grade_from_gpa(cgpa))