Merge pull request #682 from UTDNebula/fix-valid-major-double-dipping

fix(NP-96): Allow valid major double dipping

Author: cubetastic33

validator/degree_solver.py

@@ -1,16 +1,17 @@
 from __future__ import annotations
 from enum import Enum
 from glob import glob
+from collections import Counter
 
 from pydantic import Json
 
 from typing import Any
 
 import core
-from major.requirements import AbstractRequirement
+from major.requirements import AbstractRequirement, FreeElectiveRequirement
 from dataclasses import dataclass
 
-from major.requirements.map import REQUIREMENTS_MAP
+from major.requirements import loader
 import json
 
 from major.requirements.shared import (
@@ -19,6 +20,7 @@
 )
 from course import Course
 
+LOADER = loader.Loader()
 
 # Read all degree plan JSON files and store their contents in a hashmap
 # This is so that we can avoid reading all the files each time we want to get the data for a certain course
@@ -144,7 +146,7 @@ def __init__(
         requirements: DegreeRequirementsInput,
         bypasses: BypassInput,
     ) -> None:
-        self.courses = set(courses)
+        self.courses = set([Course.from_name(course) for course in courses])
         self.degree_requirements = self.load_requirements(requirements)
         self.solved_core: core.store.AssignmentStore | None = None
         self.bypasses = bypasses
@@ -187,9 +189,7 @@ def load_requirements(
 
             # Add requirements
             for req_data in requirements_data:
-                major_req.requirements.append(
-                    REQUIREMENTS_MAP[req_data["matcher"]].from_json(req_data)
-                )
+                major_req.requirements.append(LOADER.requirement_from_json(req_data))
             degree_requirements.append(major_req)
             # We don't need to check the other JSON files
             break
@@ -201,23 +201,28 @@ def load_requirements(
     def solve(self) -> DegreeRequirementsSolver:
         # Run for core
         core_solver = self.load_core()
-        self.solved_core = core_solver.solve(
-            [Course.from_name(course) for course in self.courses], []
-        )
-        # Set of the core courses that are fulfilled, so they won't be considered as free electives
-        used_core_courses = set()
+        self.solved_core = core_solver.solve(list(self.courses), [])
+
+        # Counter of the core courses and their used hours, so they won't be considered as free electives.
+        used_core_courses: Counter[Course] = Counter()
         if self.solved_core is not None:
             for req_fill in self.solved_core.reqs_to_courses.values():
-                used_core_courses.update([course.name for course in req_fill.keys()])
+                used_core_courses.update(req_fill)
 
         # Run for major
         for degree_req in self.degree_requirements:
             for course in self.courses:
-                # Make sure it's not a core course
-                if course in used_core_courses:
-                    continue
                 for requirement in degree_req.requirements:
-                    if requirement.attempt_fulfill(course):
+                    # Free elective requirements are special, since they can take left over hours from core courses.
+                    if type(requirement) == FreeElectiveRequirement:
+                        if requirement.attempt_fulfill(
+                            course.name,
+                            available_hours=(
+                                int(course.hours) - used_core_courses[course]
+                            ),
+                        ):
+                            break
+                    elif requirement.attempt_fulfill(course.name):
                         break
 
             # Handle requirements bypasses for major

validator/gen_schema.py

@@ -6,7 +6,7 @@
 from types import GenericAlias
 from typing import Any, ForwardRef
 from jsonschema import Draft7Validator
-from major.requirements import REQUIREMENTS_MAP
+from major.requirements import loader
 
 schema: dict[str, Any] = {
     "$schema": Draft7Validator.META_SCHEMA["$id"],
@@ -89,8 +89,9 @@ def forward_ref_to_schema(ref: ForwardRef) -> dict[str, Any]:
         raise Exception("Expected type, got", type(ref_type), ref_type)
 
 
-for req_name in REQUIREMENTS_MAP:
-    req = REQUIREMENTS_MAP[req_name]
+req_loader = loader.Loader()
+for req_name in req_loader.REQUIREMENTS_MAP:
+    req = req_loader.REQUIREMENTS_MAP[req_name]
     requirement_schema_props: dict[str, Any] = {"matcher": {"const": req_name}}
 
     for prop_name, prop_type in req.JSON.__annotations__.items():

validator/major/requirements/__init__.py

@@ -1,3 +1,3 @@
 from .base import AbstractRequirement
 from .shared import *
-from .map import *
+from . import loader

validator/major/requirements/base.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 from abc import abstractmethod, ABC
 from dataclasses import dataclass
-
 from typing import Any
 
 from pydantic import Json
@@ -19,6 +18,7 @@ class AbstractRequirement(ABC):
     def attempt_fulfill(
         self,
         course: str,
+        available_hours: int = 0,
     ) -> bool:
         pass
 

validator/major/requirements/edge_cases/arts_technology_emerging_communication.py

@@ -1,7 +1,8 @@
 import json
-from typing import Any, TypedDict
+from typing import Any
 
 from pydantic import Json
+from major.requirements import loader
 from major.requirements.base import AbstractRequirement
 from major.requirements.shared import MultiGroupElectiveRequirement
 import utils
@@ -45,13 +46,9 @@ def __init__(
 
     @classmethod
     def from_json(cls, json: JSON) -> MultiGroupElectiveRequirement:  # type: ignore[override]
-        from ..map import REQUIREMENTS_MAP
-
         requirements: list[AbstractRequirement] = []
         for requirement_data in json["requirements"]:
-            requirement = REQUIREMENTS_MAP[requirement_data["matcher"]].from_json(
-                requirement_data
-            )
+            requirement = loader.Loader().requirement_from_json(requirement_data)
             requirements.append(requirement)
 
         return cls(
@@ -87,7 +84,7 @@ def to_json(self) -> Json[Any]:
             }
         )
 
-    def attempt_fulfill(self, course: str) -> bool:
+    def attempt_fulfill(self, course: str, _: int = 0) -> bool:
         fulfilled = super().attempt_fulfill(course)
         if fulfilled:
             if utils.get_level_from_course(course) == 4:

validator/major/requirements/edge_cases/business_administration.py

@@ -2,13 +2,13 @@
 import json
 
 from pydantic import Json
-from major.requirements import AbstractRequirement, map
+from major.requirements import AbstractRequirement
 
-from functools import reduce
 from typing import Any, TypedDict
 from major.requirements.shared import OrRequirement
 
 import utils
+from major.requirements import loader
 
 """
 Note: assuming BA 4V90 & BA 4090 cover one of the groups
@@ -21,7 +21,7 @@ class SomeRequirement(OrRequirement):
     NOTE: Allows attempt_filled to work even if is_fulfilled() is true
     """
 
-    def attempt_fulfill(self, course: str) -> bool:
+    def attempt_fulfill(self, course: str, _: int = 0) -> bool:
         for requirement in self.requirements:
             if requirement.attempt_fulfill(course):
                 return True
@@ -66,7 +66,7 @@ def __init__(
         self.metadata = metadata
         self.override_filled = False
 
-    def attempt_fulfill(self, course: str) -> bool:
+    def attempt_fulfill(self, course: str, _: int = 0) -> bool:
         if self.is_fulfilled():
             return False
 
@@ -146,9 +146,7 @@ def from_json(cls, json: JSON) -> BusinessAdministrationElectiveRequirement:
 
         requirements: list[AbstractRequirement] = []
         for requirement_data in json["prefix_groups"]:
-            requirement = map.REQUIREMENTS_MAP[requirement_data["matcher"]].from_json(
-                requirement_data
-            )
+            requirement = loader.Loader().requirement_from_json(requirement_data)
             requirements.append(requirement)
 
         return cls(
@@ -182,4 +180,4 @@ def __str__(self) -> str:
         _______________
         Required fulfilled: {self.is_fulfilled()}
         """
-        return s
+        return s

validator/major/requirements/edge_cases/computer_science.py

@@ -2,12 +2,13 @@
 import json
 
 from pydantic import Json
-from major.requirements import AbstractRequirement, map
+from major.requirements import AbstractRequirement
 
 from functools import reduce
 from typing import Any, TypedDict
 
 import utils
+from major.requirements import loader
 
 
 class MajorGuidedElectiveRequirement(AbstractRequirement):
@@ -45,7 +46,7 @@ def __init__(
         self.metadata = metadata
         self.override_filled = False
 
-    def attempt_fulfill(self, course: str) -> bool:
+    def attempt_fulfill(self, course: str, _: int = 0) -> bool:
         if self.is_fulfilled():
             return False
 
@@ -57,7 +58,6 @@ def attempt_fulfill(self, course: str) -> bool:
             for requirement in self.also_fulfills:
                 if requirement.attempt_fulfill(course):
                     return True
-                    self.valid_courses.append(course)
 
             return False
 
@@ -112,9 +112,7 @@ def from_json(cls, json: JSON) -> MajorGuidedElectiveRequirement:
 
         also_fulfills: list[AbstractRequirement] = []
         for requirement in json["also_fulfills"]:
-            also_fulfills.append(
-                map.REQUIREMENTS_MAP[requirement["matcher"]].from_json(requirement)
-            )
+            also_fulfills.append(loader.Loader().requirement_from_json(requirement))
 
         return cls(
             json["required_count"], json["starts_with"], also_fulfills, json["metadata"]

validator/major/requirements/edge_cases/psychology.py

@@ -1,7 +1,6 @@
 from pydantic import Json
 from typing import Any, TypedDict
 from major.requirements import base
-from major.requirements.base import AbstractRequirement
 import utils
 import json
 
@@ -25,7 +24,7 @@ def __init__(
         self.accepted_courses = accepted_courses
         self.metadata = metadata
 
-    def attempt_fulfill(self, course: str) -> bool:
+    def attempt_fulfill(self, course: str, _: int = 0) -> bool:
         if self.is_fulfilled():
             return False
 

validator/major/requirements/loader.py

@@ -0,0 +1,67 @@
+from typing import Type, Literal, get_args, Mapping, TypeGuard, Any
+
+RequirementNameT = Literal[
+    "CourseRequirement",
+    "AndRequirement",
+    "OrRequirement",
+    "FreeElectiveRequirement",
+    "SelectRequirement",
+    "HoursRequirement",
+    "PrefixBucketRequirement",
+    "OtherRequirement",
+    "CSGuidedElectiveRequirement",
+    "BAGuidedElectiveRequirement",
+    "SomeRequirement",
+    "MultiGroupElectiveRequirement",
+    "ATECPrescribedElectiveRequirement",
+    "PsychologyPrefixesOrCourses",
+]
+RequirementNames: list[RequirementNameT] = list(get_args(RequirementNameT))
+
+
+class Loader:
+    from major.requirements.base import AbstractRequirement
+
+    def __init__(self) -> None:
+        from major.requirements import shared
+        from .edge_cases import (
+            business_administration,
+            computer_science,
+            arts_technology_emerging_communication,
+            psychology,
+        )
+
+        self.REQUIREMENTS_MAP: dict[
+            RequirementNameT,
+            Type[Loader.AbstractRequirement],
+        ] = {
+            # Shared requirements
+            "CourseRequirement": shared.CourseRequirement,
+            "AndRequirement": shared.AndRequirement,
+            "OrRequirement": shared.OrRequirement,
+            "FreeElectiveRequirement": shared.FreeElectiveRequirement,
+            "SelectRequirement": shared.SelectRequirement,
+            "HoursRequirement": shared.HoursRequirement,
+            "PrefixBucketRequirement": shared.PrefixBucketRequirement,
+            "OtherRequirement": shared.OtherRequirement,
+            # Computer Science Edge Cases
+            "CSGuidedElectiveRequirement": computer_science.MajorGuidedElectiveRequirement,
+            # Business Administration Edge Cases
+            "BAGuidedElectiveRequirement": business_administration.BusinessAdministrationElectiveRequirement,
+            "SomeRequirement": business_administration.SomeRequirement,
+            "MultiGroupElectiveRequirement": shared.MultiGroupElectiveRequirement,
+            "ATECPrescribedElectiveRequirement": arts_technology_emerging_communication.ATECPrescribedElectiveRequirement,
+            # Psychology
+            "PsychologyPrefixesOrCourses": psychology.PsychologyPrefixesOrCourses,
+        }
+
+    def requirement_from_json(self, json: Mapping[str, Any]) -> AbstractRequirement:
+        if not "matcher" in json:
+            raise ValueError(f"Invalid requirement: {json}, missing 'matcher' key.")
+        if not self._is_valid_requirement(json["matcher"]):
+            raise ValueError(f"Invalid requirement: {json}")
+
+        return self.REQUIREMENTS_MAP[json["matcher"]].from_json(json)
+
+    def _is_valid_requirement(self, requirement: str) -> TypeGuard[RequirementNameT]:
+        return requirement in self.REQUIREMENTS_MAP