phowell
/
canvasapp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
canvasapp/degrees.py

681 lines
22 KiB
Python
Raw Blame History

from lark import Lark, Transformer, v_args
import json, sys, re, codecs
import lark
"""describe college courses, their number of units, any other courses that are prerequisites, as well as various degrees which
consist of groups of courses that must be taken. The groups have rules associated with them, such as:
- take all (the following courses)
- take n (where n=3 or 5 or something)
- take at least n units from the following list (so the taken course's unit value must add up to n or greater)
- and so on."""
def num(s):
if s == '': return 0
try:
return int(s)
except ValueError:
return float(s)
def num_units(s):
if s == '': return 0
m = re.match(r'^(\d+)\.?(\d+)?\s?(units)?$',s)
if m:
if m.group(1) and m.group(2):
if m.group(2) == '0':
return int(m.group(1))
return float(f"{m.group(1)}.{m.group(2)}")
elif m.group(1):
return int(m.group(1))
else:
try:
return int(s)
except ValueError:
return float(s)
class CourseOr:
def __init__(self, subs):
self.names = subs
self.name = " or ".join(self.names)
def __repr__(self):
return f"[{self.name}]"
class Course:
def __init__(self, name, units, prerequisites=[]):
self.name = name
self.units = units
self.prerequisites = prerequisites
def __repr__(self):
#return f"{self.name} ({self.units} units)"
return f"{self.name}"
class CourseList:
def __init__(self, name, course_list):
self.name = name
self.course_list = course_list
self.l = len(course_list)
def __iter__(self):
return iter(self.course_list)
def __len__(self):
print("What is this len? ", len(self.course_list), str(list(self.course_list)), str(type(self.course_list)))
i = 1
for c in self.course_list:
i += 1
return i
#return len(self.course_list)
def __repr__(self):
return ", ".join([f"\"{str(x)}\"" for x in self.course_list]) # .course_list
#return f"{s}"
#return f"CourseList({self.name}, {s})"
class DegreeRule:
def __init__(self, rule_type, course_list):
self.rule_type = rule_type
if 'n' in rule_type.__dict__: self.n = rule_type.n
self.course_list = course_list
print("COURSELIST: ", type(self.course_list), self.course_list)
def mz_rule(self,n):
s = ",".join( [ f"{x}" for x in self.course_list])
i = 0
for c in self.course_list:
i += 1
#print("What is this len? ", len(self.course_list), str(list(self.course_list)), str(type(self.course_list)))
t = len(list(self.course_list))
if not type(self.course_list)==tuple:
t = self.course_list.l
return f"array[1..{t}] of string: rule_{n}_courses = [{s}];"
def __repr__(self):
return self.mz_rule(1)
#return f"DegreeRule({self.rule_type}, {self.course_list})"
class Degree:
def __init__(self, name, degree_rules):
self.name = name
self.degree_rules = degree_rules
def mz_rule(self):
n = 1
s = f"% Degree: {self.name}\n"
for r in self.degree_rules:
s += r.mz_rule(n) + "\n"
n += 1
return s
def __repr__(self):
#x = ", ".join([str(x) for x in self.degree_rules])
#return f"Degree({self.name}, {x})"
return self.mz_rule()
class RuleType():
def __init__(self,what,n=0):
self.what = what
self.n = n
def __repr__(self):
return "" #f"RuleType({self.what}, {self.n})"
class Rule:
pass
class TakeAll(Rule):
def __repr__(self):
return f"Take all:"
class TakeN(Rule):
def __init__(self, n):
self.n = n
def __repr__(self):
return f"Take {self.n} courses:"
class TakeNUnits(Rule):
def __init__(self, n):
self.n = n
def __repr__(self):
return f"Take {self.n} units:"
@v_args(inline=True)
class DSLTransformer(Transformer):
def __init__(self):
self.courses = {}
self.degrees = {}
self.lists = {}
def course_declaration(self, name, units):
#return Course(name, int(units), prerequisites.children)
#print(items)
#if type(items[0]) == str:
c = Course(name.value, units)
self.courses[name.value] = c
#else:
#options = [x.value for x in items[0].children]
#label = "[OR " + options[0] + "...]"
#c = CourseOr(label, options)
#self.courses[label] = c
'''def program(self, name, rules):
self.degrees[name.value] = Degree(name.value, rules)
return self.degrees[name.value]'''
def rule_type(self, items):
what = items[0]
n = None
if len(items) == 2:
n = int(items[1])
return RuleType(what, n)
def take_all(self):
return TakeAll()
def take_n_courses(self, n):
return TakeN(n)
def take_n_units(self, n):
return TakeNUnits(n)
def degree_rule(self, rule_type, *course_list):
#if type(course_list[0])==type([]):
# return DegreeRule(rule_type, course_list[0])
print("making DegreeRule: ", rule_type, type(course_list), course_list)
return DegreeRule(rule_type, course_list)
def list_declaration(self, name, course_list):
print("declared course list: ", name.value, course_list)
cl = CourseList(name.value, course_list)
self.lists[name.value] = cl
return cl
def list_ref(self, name):
print("referenced course list: ", name.value, type(self.lists[name.value]), self.lists[name.value])
return self.lists[name.value]
def course(self, *items):
return Course(items[0].value,"")
def course_or(self, *items):
return CourseOr([x.value for x in items])
def course_list(self, *items):
#print(str(items))
print("course list: ", items)
return CourseList("temp", items)
#return [c for c in items]
def program(self, *items):
#print(items)
name = items[0].value
rules = items[1:]
self.degrees[name] = Degree(name, rules)
return self.degrees[name]
"""
dsl = DSLTransformer()
dsl.course('CS101', 3)
dsl.course('CS102', 3, prerequisites=['CS101'])
dsl.course('MATH101', 3)
dsl.degree('CS', [
dsl.take_all(['CS101', 'CS102']),
dsl.take_n_units(['CS101', 'CS102', 'MATH101'], 9),
dsl.take_n(['CS101', 'CS102', 'MATH101'], 2),
])
print(dsl.courses)
print(dsl.degrees)
"""
#(course ","?)*
grammar = """
start: _spec+
_spec: program | course_declaration | list_declaration
program: "program" PROGRAMNAME degree_rule*
degree_rule: "take" rule_type [course_list | list_ref]
list_ref: LISTNAME
rule_type: "all from" -> take_all
| "at least" INT "units from" -> take_n_units
| "at least" INT "courses from" -> take_n_courses
| "at least" INT "course from" -> take_n_courses
list_declaration: "list" LISTNAME ":" course_list
course_declaration: "course" COURSECODE UNITAMOUNT "units" ["prerequisites" (COURSECODE ","?)*]
course_list: [course | course_or] ["," [course | course_or]]*
course: COURSECODE
course_or: COURSECODE "or" COURSECODE
COURSECODE: ("A".."Z")+ INT+ ["A".."Z"]*
PROGRAMNAME: ("A".."Z" | "a".."z")+
LISTNAME: ("a".."z"["A".."Z" | "a".."z" | INT]+)
UNITAMOUNT: NUMUNITS | NUMUNITS "-" NUMUNITS
NUMUNITS: INT | INT "." INT
%import common.INT
%import common.WS
%ignore WS
"""
def parser():
dsl = """
course CSIS1 2 units
course CSIS2 4 units
course ACCT120 3 units
course ACCT20 4 units
course BUS1 3 units
course ENGL250 3 units
course ACCT105 3 units
course ACCT121 3 units
course BOT100 3 units
course BOT105B 3 units
list a1: CMUN1A, CMUN5, CMUN8, CMUN10
list a2: ENGL1A
list a3: PHIL2, PHIL4, ENGL1C, CMUN3
list b1: ASTR1, CHEM1A, CHEM1B, CHEM12A, CHEM12B
list b2: AH15, ANTH1, BIO1, BIO2, BIO4, BIO5
list b3: CHEM1A, ANTH1, BIO4, BIO5
list b4: BUS14, BUS11 or ECON11, ECON14, MATH1A, MATH1B
list c1: BUS1, ENGL250, ACCT120, BOT100, ACCT121, BOT105B
program BusinessAccountingOption
take all from CSIS1, CSIS2
take at least 6 units from ACCT120, ACCT20 or ECON20
take at least 3 courses from MUS5, MUS10, BUS1, ENGL250, ACCT120, BOT100, ACCT121, BOT105B
take at least 1 course from c1
program CSUGenEd
take at least 1 course from a1
take at least 1 course from a2
take at least 1 course from a3
"""
do_parse(dsl)
def do_parse(dsl):
parser = Lark(grammar)
print(parser.parse(dsl).pretty())
print("\n\n\n")
print("\nTRANSFORMER: ")
parser = Lark(grammar)
transformer = DSLTransformer()
def parse_dsl(dsl):
tree = parser.parse(dsl)
return transformer.transform(tree)
result = parse_dsl(dsl)
print(transformer.courses)
print()
print(transformer.degrees)
print()
print(transformer.lists)
print()
[print(c) for c in transformer.courses]
print()
print("\nDEGREES: ")
for d,i in transformer.degrees.items():
print(str(i))
print()
[print(d) for d in transformer.lists]
def rule_check_units():
# Define the course units and passing grades
course_units = {
"A": 1,
"B": 2,
"C": 1,
"D": 3
}
# Define the students and their passed courses
students = {
"Peter": ["A", "B", "C"],
"Mark": ["D", "B"],
"Susan": ["A", "B"]
}
# Define the minimum units required to graduate
min_units_to_graduate = 4
calcs = {}
for student, passed_courses in students.items():
print("\n", student, passed_courses)
for c in passed_courses:
print(f"\t{c:15} {course_units[c]}")
print(f"\t{'Total':15} {sum(course_units[c] for c in passed_courses)}")
# Determine the graduating students
graduating_students = [
student for student, passed_courses in students.items()
if sum(course_units[course] for course in passed_courses) >= min_units_to_graduate
]
# Print the graduating students
if graduating_students:
print("The graduating students are:", ", ".join(graduating_students))
else:
print("No students meet the graduation requirements.")
"""
def compute_degree_progress(student_courses, degree):
total_units_completed = 0
total_required_units = 0
for course in degree['required_courses']:
if course['id'] in student_courses:
total_units_completed += course['units']
if 'additional_rules' in course:
for rule in course['additional_rules']:
if rule['type'] == 'at_least_n_units_from_list':
units_from_list = sum([c['units'] for c in degree['courses'] if c['id'] in student_courses and c['id'] in rule['course_list']])
if units_from_list < rule['n']:
break
total_required_units += course['units']
progress_percent = total_units_completed / total_required_units * 100 if total_required_units > 0 else 0
return progress_percent
"""
word_to_num = {'course':1, 'One':1, 'one':1, 'two':2, 'three':3, 'four':4, 'five':5, 'six':6,
'seven':7, 'eight':8, 'nine':9, 'ten':10, 'eleven':11,}
def word2num(word, verbose=0):
word = word.lower()
ret = word_to_num[word] if word in word_to_num else word
if verbose:
print(f" word2num({word}) -> {ret}")
return ret
lab_classes = {}
def load_lab_classes():
global lab_classes
if lab_classes:
return lab_classes
for c in json.loads(codecs.open('cache/courses/courses_built.json','r','utf-8').read()).values():
#print(c)
if 'min_lab_hour' in c and float(c['min_lab_hour']) > 0:
lab_classes[c['dept'] + c['number']] = 1
print(lab_classes)
return lab_classes
def is_lab_class(c):
lab_classes = load_lab_classes()
if c in lab_classes:
return True
return False
def is_noncourse_new_section(noncourse_line):
from degree_vars import note_true_section, note_false_section
for non in note_false_section:
if re.search(non, noncourse_line):
#print(f"- {noncourse_line}")
return False
for yes in note_true_section:
if re.search(yes, noncourse_line):
#print(f"+ {noncourse_line}")
return True
print(f" -> should this start a new rule/section? [{noncourse_line}]")
return False
rule_lookup = {
'take_all_prereq': ['RN PROGRAM PREREQUISITES', 'PREREQUISITES', ],
'take at least n courses': ['(\d+) courses total', 'SELECT (ONE|TWO) OF THE FOLLOWING', 'Select (one|two|three)', 'Select (\d+) courses',
'Choose (one) or more', 'Choose (one|two|three) of the classes listed',
'Choose (\w+) of the following','Choose (one|two|three)', 'Choose ([\d\w]+) courses from',
'ANY (COURSE) NOT USED IN', 'Select (1)', 'Select (one) of the following REQUIRED CORE',
'(One) of the following:', 'LIST [AB]: Select (\d)', 'Choose (One) Course:', ],
'take at least n units': ['LIST A \((\d+) units\)', 'LIST B \((\d+) units\)', 'LIST C \- Any course .*\((\d+) units\)', '(\d+) units total', 'Select (\d+) units', 'Any combination totaling (\d+) units',
'Choose (\w+) units from classes listed', 'Choose a minimum of ([\w\d]+) units from',
'Choose any combination of courses for a minimum of ([\w\d]+) units',
'Choose ([\w\d]+) units', 'Choose courses for at least ([\w\d]+) units',
'Choose a minimum of (\d+) units', 'Select any (\d+)\-\d+ units from the following'],
'electives': ['Electives', 'Recommended electives?:', ],
'take_all': ['RN PROGRAM', 'REQUIRED CORE', 'CORE COURSES', 'ADDITIONAL REQUIREMENTS','REQUIREMENTS:', 'Requirements', 'Core Requirements',
'Required Core', 'REQUIRED', 'LVN PROGRAM', 'Student Teaching Practicum', '^LIST A:?$', '^LIST B:$',
'Program Requirements', 'Required Courses:', 'PROGRAM REQUIREMENTS (5 Units)', 'PROGRAM REQUIREMENTS (162 Hours)',
],
}
def lookup_rule(line):
verbose = 0
for key in rule_lookup.keys():
for each in rule_lookup[key]:
m = re.search(each, line)
if m:
num = None
try:
if m.group(1):
num = m.group(1)
except Exception as e:
pass
if verbose: print(f"line: {line} matched: {each} with {num}")
return key,num
return None,None
def examine(li,award, verbose=0):
summary = [x[0] for x in li]
if summary[1] in ['and','or']:
if verbose: print(" - ", summary)
def check_ands_ors_pbd(award, pbd, verbose=0):
verbose = 0
if verbose: print(f"check_ands_ors_pbd({award}, ...)")
summary = [x[0] for x in pbd]
if verbose: print(" ", summary)
# iterate through in groups of 3, from 0/1/2 up to 3/4/5
# (for length 6. length n: n-2, n-1, n)
for i in range(len(pbd)-2):
examine(pbd[i:i+3], award, verbose)
if verbose: print()
def build_catalog():
cfile = "cache/courses/courses_active_built.json"
pfile = "cache/programs/programs_built.json"
courses = json.loads(codecs.open(cfile,'r','utf-8').read())
programs = json.loads(codecs.open(pfile,'r','utf-8').read())
course_spec = []
for index,c in courses.items():
try:
d = c['dept']
n = c['number']
name = c['name']
u2 = num_units(c['min_units'])
if 'max_units' in c:
u1 = num_units(c['max_units'])
else:
u1 = u2
if u1 == u2:
units = {'units': u1}
u = u1
else:
units = {'min_units': u2, 'max_units': u1}
u = f"{u2}-{u1}"
course_spec.append(f"course {d}{n} {u} units")
except Exception as e:
pass
#print(e)
#print(json.dumps(c,indent=2))
d_out = codecs.open('cache/prog_debug.txt','w','utf-8')
def d(s): d_out.write(str(s) + "\n")
for index,p in programs.items():
v2 = 0 # print debugging stuff
# Each award (degree or certificate)
award = p['award'] + " " + p['program_title']
d("\n" + p['award'] + " " + p['program_title'])
print("\n" + award)
this_program = p['award'] + " " + p['program_title']
this_rule = ""
r = p['requirements']
course_count = 0
# Each numbered chunk (k) in the requirements section
for k in sorted(r.keys()):
# Each 'program block definition'
# 1st is dict with unit totals, rest are lists.
check_ands_ors_pbd( award, sorted( r[k][1:], key=lambda x: float(x[1])) )
for each_r in sorted( r[k][1:], key=lambda x: float(x[1])):
if each_r[0] in ['and','or']:
#print(' ', each_r[0],each_r[1])
pass
if isinstance(each_r, list):
#print(each_r)
if each_r[0] == 'h3' or (each_r[0]=='noncourse' and is_noncourse_new_section(each_r[2])):
# This is a rule title
if this_rule and course_count:
d(this_rule) # + f" ({course_count}) "
course_count = 0
raw_rule = each_r[2]
good_rule, num = lookup_rule(raw_rule)
if good_rule:
#print(f"\t{good_rule}")
n = word2num(num) if num else ""
if v2: print(f"\tn = {n}")
actual_rule = re.sub(r'\sn\s',f' {n} ',good_rule)
if v2: print(f"\tactual rule is: {actual_rule}")
#this_rule = f"{good_rule} ({n}) [{raw_rule}] from "
this_rule = f"{actual_rule} from "
else:
#print(f"\t{raw_rule}")
if not this_rule:
this_rule = "take_all from "
this_rule = " * " + raw_rule + " " + "from "
#elif each_r[0] == 'noncourse': # also a rule title, some kind of sub-rule?
# d( f" ++ (noncourse) {each_r[2]}")
elif each_r[0] == 'course': # course in a rule
if not this_rule:
this_rule = "take_all from "
is_lab = '[L]' if is_lab_class(each_r[2]['code']) else ''
#this_rule += f"{each_r[2]['code']}{is_lab}({each_r[1]}), "
this_rule += f"{each_r[2]['code']}{is_lab}, "
if v2: print(f"\t\tthis rule is now: {this_rule}")
course_count += 1
if course_count:
d(this_rule) # + f" ({course_count})"
d_out.close()
d_in = codecs.open('cache/prog_debug.txt','r','utf-8').readlines()
progs = []
this_prog = []
for line in d_in:
if line.strip() == '':
if this_prog:
progs.append(this_prog)
this_prog = []
else:
this_prog.append(line.strip())
okay = []
notokay = []
for p in progs:
ok =1
for line in p:
if line[0] == '*':
notokay.append(p)
ok = 0
continue
if ok:
okay.append(p)
print("These programs are okay:")
for p in okay:
for l in p:
print(l)
print()
print("\n\nThese programs are not okay:")
for p in notokay:
for l in p:
print(l)
print()
print(f"okay: {len(okay)}")
print(f"not okay: {len(notokay)}")
return
do_parse('\n'.join(course_spec))
## TODO or and and
## How to see this as a 'fake' course: Eligible for English 1A ?
## How to include this as part of a list: 'ANY COURSE NOT USED IN LIST A (3 units)'
if __name__ == "__main__":
options = { 1: ['parsing example',parser] ,
2: ['rule check by units',rule_check_units] ,
3: ['load all programs',build_catalog] ,
}
print ('')
if len(sys.argv) > 1 and re.search(r'^\d+',sys.argv[1]):
resp = int(sys.argv[1])
print("\n\nPerforming: %s\n\n" % options[resp][0])
else:
print ('')
for key in options:
print(str(key) + '.\t' + options[key][0])
print('')
resp = input('Choose: ')
# Call the function in the options dict
options[ int(resp)][1]()
Reference in New Issue View Git Blame Copy Permalink