requisite_processor 0.2.5__tar.gz → 0.2.7__tar.gz

{requisite_processor-0.2.5 → requisite_processor-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: requisite_processor
-Version: 0.2.5
+Version: 0.2.7
 Summary: Module for working with course requisite data and checking requisite satisfaciton.
 Author: Michael Hickman
 Author-email: mhickman@unm.edu
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Description-Content-Type: text/markdown
 
 # Requisite Processor

{requisite_processor-0.2.5 → requisite_processor-0.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "requisite_processor"
-version = "0.2.5"
+version = "0.2.7"
 description = "Module for working with course requisite data and checking requisite satisfaciton."
 authors = ["Michael Hickman <mhickman@unm.edu>"]
 readme = "README.md"

{requisite_processor-0.2.5 → requisite_processor-0.2.7}/requisite_processor/requisite_processor.py

@@ -1,9 +1,14 @@
 import re
+from typing import List, Union
 from requisite_processor.requisite_check import RequisiteCheckResult
 
+def somefunc(a):
+    return a
+
 class RequisiteProcessor:
-    def __init__(self, prerequisites: dict):
+    def __init__(self, prerequisites: dict, course_equivalents: Union[dict, None] = None):
         self.prerequisite_rules = prerequisites
+        self.course_equivalents = course_equivalents
 
     @property
     def availabile_academic_periods(self) -> list[str]:
@@ -30,7 +35,7 @@ class RequisiteProcessor:
     def check_satisfaction(
             self,
             course_code: str,
-            courses_taken: list[dict] = None,
+            courses_taken: Union[list[dict], None] = None,
             test_scores = None,
             academic_period = None,
             ignore_tests = False,
@@ -68,6 +73,12 @@ class RequisiteProcessor:
         if courses_taken is None:
             courses_taken = []
 
+        if self.course_equivalents is not None:
+            for ct in courses_taken:
+                if ct['code'] in self.course_equivalents:
+                    ct['code'] = self.course_equivalents[ct['code']]['code']
+
+
         if academic_period is None:
             academic_period = self.latest_available_academic_period
 
@@ -88,6 +99,31 @@ class RequisiteProcessor:
         return self.__traverse_prereqs(prereq_rule, academic_period, courses_taken, test_scores, ignore_grades)
 
 
+    def fast_check(self, course_code: str, courses_taken = None, test_scores = None, academic_period = None) -> bool:
+        if academic_period is None:
+            academic_period = self.latest_available_academic_period
+
+        if academic_period not in self.prerequisite_rules:
+            raise self.AcademicPeriodNotFound(f"The academic period '{academic_period}' is not found in the given prerequisite data.")
+
+        if course_code not in self.prerequisite_rules[academic_period]:
+            raise self.CourseNotFound(f"Course {course_code} not found in {academic_period}")
+
+        prereq_rule = self.prerequisite_rules[academic_period][course_code]
+
+        if prereq_rule is None:
+            return True
+
+        if courses_taken is None:
+            courses_taken = []
+
+        if test_scores is None:
+            test_scores = {}
+
+        return self.__fast_check(prereq_rule, courses_taken, test_scores)
+
+
+
     def __grade_score(self, grade) -> float:
         grades = {
             'A+': 4.3, 'A': 4, 'A-': 3.7,
@@ -104,9 +140,13 @@ class RequisiteProcessor:
 
     def __traverse_prereqs(self, prereq_data: dict, academic_period, courses_taken, test_scores, ignore_grades):
         if prereq_data['type'] == 'course':
+            prereq_code = prereq_data['course']['code']
+            if self.course_equivalents is not None and prereq_code in self.course_equivalents:
+                prereq_code = self.course_equivalents[prereq_code]['code']
+
             selected_course = None
             for course in courses_taken:
-                if course['code'] == prereq_data['course']['code'] and (ignore_grades is True or self.__grade_score(course['grade']) >= self.__grade_score(prereq_data['minimum_course_grade'])):
+                if course['code'] == prereq_code and (ignore_grades is True or self.__grade_score(course['grade']) >= self.__grade_score(prereq_data['minimum_course_grade'])):
                     selected_course = course
                     break
 
@@ -157,8 +197,9 @@ class RequisiteProcessor:
             prereq_operands = []
 
             for sub_prereq_data in prereq_data['operands']:
-                if sub_prereq_data['type'] == 'course' and sub_prereq_data['concurrency_ind'] is True:
-                    continue
+                # TODO : Consider how to handle concurrency
+                # if sub_prereq_data['type'] == 'course' and sub_prereq_data['concurrency_ind'] is True:
+                #     continue
 
                 prereq_operands.append(sub_prereq_data)
 
@@ -187,6 +228,43 @@ class RequisiteProcessor:
             return result
 
 
+    def __fast_check(self, prereq_data: dict, courses_taken: List[str], test_scores: dict) -> bool:
+        if prereq_data['type'] == 'placement_test':
+            test_code = prereq_data['placement_test']['test_code']
+            if test_code not in test_scores:
+                return False
+
+            if test_scores[test_code] >= prereq_data['minimum_test_score']:
+                return True
+            else:
+                return False
+
+        if prereq_data['type'] == 'course':
+            for course in courses_taken:
+                if course == prereq_data['course']['code']:
+                    return True
+
+            return False
+
+
+        if prereq_data['type'] == 'and':
+            for sub_prereq_data in prereq_data['operands']:
+                if self.__fast_check(sub_prereq_data, courses_taken, test_scores) is False:
+                    return False
+
+            return True
+
+
+        if prereq_data['type'] == 'or':
+            for sub_prereq_data in prereq_data['operands']:
+               if self.__fast_check(sub_prereq_data, courses_taken, test_scores) is True:
+                    return True
+
+            return False
+
+        return False
+
+
     def __reduce_rule(self, prereq_data, filter_rule):
         if prereq_data is None:
             return None