quatalog-scraper/CourseOfferingsScraper.cpp

301 lines
12 KiB
C++
Raw Normal View History

2023-02-04 17:38:37 +00:00
#include<set>
#include<regex>
#include<fstream>
#include<iostream>
#include<filesystem>
2023-02-05 00:32:25 +00:00
#include<unordered_set>
2023-02-04 17:38:37 +00:00
#include<dist/jsoncpp.cpp>
namespace fs = std::filesystem;
2023-02-05 02:09:05 +00:00
struct quatalog_data_t {
Json::Value terms_offered;
Json::Value prerequisites;
};
using course_handler_t = void(const Json::Value&,const std::string&,quatalog_data_t&,const Json::Value&);
void handle_term_dirs(const std::set<fs::directory_entry>&,quatalog_data_t&);
void handle_term(const fs::directory_entry& term_entry,quatalog_data_t&);
void handle_prefix(const Json::Value&,const std::string&,quatalog_data_t&,const Json::Value&,course_handler_t*);
void handle_course(const Json::Value&,const std::string&,quatalog_data_t&,const Json::Value&);
void handle_course_summer(const Json::Value&,const std::string&,quatalog_data_t&,const Json::Value&);
void handle_everything(const Json::Value& sections,
const Json::Value& title,
Json::Value& course_term,
Json::Value&);
void handle_sections(const Json::Value& sections,
Json::Value& course_term);
void handle_instructors(const Json::Value& section,
std::unordered_set<std::string>& instructors);
void handle_multiple_instructors(const std::string& instructor_str,
std::unordered_set<std::string>& instructors);
void handle_attributes(const Json::Value& section,
Json::Value& course_term);
void handle_attribute(const std::string& attribute,
Json::Value& attributes);
2023-02-04 17:38:37 +00:00
int main(const int argc,const char** argv) {
2023-02-05 02:09:05 +00:00
if(argc < 3) {
2023-02-04 17:38:37 +00:00
std::cerr << "Bad number of arguments " << argc << std::endl;
return EXIT_FAILURE;
}
2023-02-05 02:09:05 +00:00
const auto& data_dir_path = fs::path(argv[1]);
const std::string& terms_offered_filename = std::string(argv[2]);
2023-02-04 17:38:37 +00:00
if(!fs::is_directory(data_dir_path)) {
std::cerr << "Data dir argument " << data_dir_path << " is not a directory" << std::endl;
return EXIT_FAILURE;
}
2023-02-04 22:29:50 +00:00
// Sort term dirs chronologically using a std::set
2023-02-04 17:38:37 +00:00
std::set<fs::directory_entry> term_dirs;
2023-02-04 22:29:50 +00:00
const auto data_dir = fs::directory_iterator(data_dir_path);
for(const auto& term : data_dir) {
2023-02-04 17:38:37 +00:00
term_dirs.insert(term);
}
2023-02-04 22:29:50 +00:00
// Begin JSON manipulation
2023-02-05 02:09:05 +00:00
quatalog_data_t data;
handle_term_dirs(term_dirs,data); //terms_offered,prerequisites);
2023-02-04 22:29:50 +00:00
2023-02-05 02:09:05 +00:00
std::fstream terms_offered_file{terms_offered_filename,std::ios::out};
terms_offered_file << data.terms_offered << std::endl;
terms_offered_file.close();
2023-02-04 22:29:50 +00:00
return EXIT_SUCCESS;
}
void handle_term_dirs(const std::set<fs::directory_entry>& term_dirs,
2023-02-05 02:09:05 +00:00
quatalog_data_t& data) {
2023-02-04 17:38:37 +00:00
for(auto term : term_dirs) {
if(!fs::is_directory(term)) {
continue;
}
2023-02-05 02:09:05 +00:00
handle_term(term,data);
2023-02-04 17:38:37 +00:00
}
}
2023-02-05 02:09:05 +00:00
void handle_term(const fs::directory_entry& term_entry,quatalog_data_t& data) {
2023-02-04 17:38:37 +00:00
const fs::path dir = term_entry.path();
const auto dirname = dir.string();
const auto term = dir.stem().string();
const auto courses_filename = dirname + "/courses.json";
const auto prereqs_filename = dirname + "/prerequisites.json";
std::fstream courses_file{courses_filename,std::ios::in};
std::fstream prereqs_file{prereqs_filename,std::ios::in};
2023-02-04 20:06:20 +00:00
std::cerr << "Processing term " << term << "..." << std::endl;
2023-02-05 02:09:05 +00:00
data.terms_offered["all_terms"].append(term);
2023-02-04 17:38:37 +00:00
Json::Value courses;
2023-02-05 02:09:05 +00:00
Json::Value prereqs;
2023-02-04 17:38:37 +00:00
courses_file >> courses;
2023-02-05 02:09:05 +00:00
prereqs_file >> prereqs;
2023-02-04 22:29:50 +00:00
course_handler_t* course_handler;
if(term.substr(4,2) == "05") {
course_handler = handle_course_summer;
} else {
course_handler = handle_course;
}
for(auto& prefix : courses) {
2023-02-05 02:09:05 +00:00
handle_prefix(prefix,term,data,prereqs,course_handler);
2023-02-04 20:06:20 +00:00
}
2023-02-05 02:09:05 +00:00
courses_file.close();
prereqs_file.close();
2023-02-04 20:06:20 +00:00
}
2023-02-04 22:29:50 +00:00
void handle_prefix(const Json::Value& prefix,
const std::string& term,
2023-02-05 02:09:05 +00:00
quatalog_data_t& data,
const Json::Value& prereqs,
2023-02-04 22:29:50 +00:00
course_handler_t course_handler) {
2023-02-04 17:38:37 +00:00
#ifdef DEBUG
2023-02-04 20:06:20 +00:00
std::cerr << "\tProcessing prefix "
<< prefix["code"]
<< " - "
<< prefix["name"]
<< "..."
<< std::endl;
2023-02-04 17:38:37 +00:00
#endif
2023-02-04 22:29:50 +00:00
for(auto& course : prefix["courses"]) {
2023-02-05 02:09:05 +00:00
course_handler(course,term,data,prereqs);
2023-02-04 17:38:37 +00:00
}
}
2023-02-04 22:29:50 +00:00
void handle_course(const Json::Value& course,
const std::string& term,
2023-02-05 02:09:05 +00:00
quatalog_data_t& data,
const Json::Value& prereqs) {
2023-02-04 17:38:37 +00:00
const auto course_code = course["id"].asString();
2023-02-04 20:06:20 +00:00
2023-02-05 02:09:05 +00:00
auto& course_term = data.terms_offered[course_code][term];
2023-02-04 17:38:37 +00:00
2023-02-04 22:29:50 +00:00
const Json::Value& sections = course["sections"];
2023-02-05 02:09:05 +00:00
handle_everything(sections,course["title"],course_term,data.prerequisites);
2023-02-04 20:06:20 +00:00
}
2023-02-04 22:29:50 +00:00
void handle_course_summer(const Json::Value& course,
const std::string& term,
2023-02-05 02:09:05 +00:00
quatalog_data_t& data,
const Json::Value& prereqs) {
2023-02-04 22:29:50 +00:00
const auto course_code = course["id"].asString();
// sections[0]: Full term sections
// sections[1]: First-half term sections
// sections[2]: Second-half term sections
// Of course, a course will never be offered
// in both the full term _and_ one of the
// half-terms, but there are a few that
// are offered in both halves (e.g. STSO-4100)
std::array<Json::Value,3> sections;
// We will loop twice over the sections,
// once here and once in handle_sections,
// but frankly I tried to make it all in 1
// loop and the code was a total unreadable
// mess. So I don't really care
int subterm;
bool subterm0 = false, subterm1 = false, subterm2 = false;
for(const auto& section : course["sections"]) {
const auto& timeslot = section["timeslots"][0];
const std::string& dateEnd = timeslot["dateEnd"].asString();
const std::string& dateStart = timeslot["dateStart"].asString();
subterm = 0;
if(dateStart.substr(0,2) != "05") {
subterm = 1;
subterm1 = true;
} else if(dateEnd.substr(0,2) != "08") {
subterm = 2;
subterm2 = true;
} else {
subterm0 = true;
}
sections[subterm].append(section);
}
2023-02-05 02:09:05 +00:00
auto& course_terms = data.terms_offered[course_code];
2023-02-04 22:29:50 +00:00
if(subterm0) {
2023-02-05 02:09:05 +00:00
handle_everything(sections[0],course["title"],course_terms[term],data.prerequisites);
2023-02-04 22:29:50 +00:00
} else {
if(subterm1) {
2023-02-05 02:09:05 +00:00
handle_everything(sections[1],course["title"],course_terms[term+"02"],data.prerequisites);
2023-02-04 22:29:50 +00:00
} if(subterm2) {
2023-02-05 02:09:05 +00:00
handle_everything(sections[2],course["title"],course_terms[term+"03"],data.prerequisites);
2023-02-04 22:29:50 +00:00
}
}
}
2023-02-05 02:09:05 +00:00
void handle_everything(const Json::Value& sections,
const Json::Value& title,
Json::Value& course_term,
Json::Value& course_prerequisites) {
course_term["title"] = title;
handle_sections(sections,course_term);
handle_attributes(sections[0],course_term);
//handle_prereqs(sections[0],course_prerequisites);
}
2023-02-04 22:29:50 +00:00
void handle_sections(const Json::Value& sections,
Json::Value& course_term) {
2023-02-04 20:06:20 +00:00
int credMin = Json::Value::maxInt, credMax = 0;
int seatsTaken = 0, capacity = 0, remaining = 0;
2023-02-05 00:32:25 +00:00
std::unordered_set<std::string> instructors;
2023-02-04 22:29:50 +00:00
for(const auto& section : sections) {
2023-02-04 20:06:20 +00:00
// Get min/max credits *of all sections*
// (RCOS looking at you)
credMin = std::min(credMin,section["credMin"].asInt());
credMax = std::max(credMax,section["credMax"].asInt());
// Add seating data of all sections together.
// remaining might get clobbered by some sections
// having negative seats, but this probably won't
// be too much of an issue
seatsTaken += section["act"].asInt();
capacity += section["cap"].asInt();
remaining += section["rem"].asInt();
2023-02-05 00:32:25 +00:00
handle_instructors(section,instructors);
2023-02-04 20:06:20 +00:00
}
course_term["credits"]["min"] = credMin;
course_term["credits"]["max"] = credMax;
course_term["seats"]["taken"] = seatsTaken;
course_term["seats"]["capacity"] = capacity;
course_term["seats"]["remaining"] = remaining;
2023-02-05 00:32:25 +00:00
for(const auto& instructor : instructors) {
course_term["instructors"].append(instructor);
}
}
void handle_instructors(const Json::Value& section,
std::unordered_set<std::string>& instructors) {
for(const auto& timeslot : section["timeslots"]) {
handle_multiple_instructors(timeslot["instructor"].asString(),instructors);
}
}
void handle_multiple_instructors(const std::string& instructor_str,
std::unordered_set<std::string>& instructors) {
// Pseudo-string split on commas
const auto delim = std::regex(", ?");
const auto end_itr = std::sregex_token_iterator();
auto instructors_itr = std::sregex_token_iterator(
instructor_str.begin(),
instructor_str.end(),
delim,
-1
);
for(;instructors_itr != end_itr
&& !instructors_itr->str().empty();
instructors_itr++) {
const std::string& str = instructors_itr->str();
if(str == "TBA") continue;
instructors.insert(str);
}
2023-02-04 20:06:20 +00:00
}
2023-02-04 22:29:50 +00:00
void handle_attributes(const Json::Value& section,
Json::Value& course_term) {
2023-02-04 20:06:20 +00:00
// This mess is basically C++'s string split but not using
// as much memory as an actual string split
2023-02-04 17:38:37 +00:00
const auto delim = std::regex(" and |, ");
const auto attributes_str = section["attribute"].asString();
const auto end_itr = std::sregex_token_iterator();
auto attributes_itr = std::sregex_token_iterator(
attributes_str.begin(),
attributes_str.end(),
delim,
-1
);
2023-02-04 20:06:20 +00:00
// Makes the JSON list of attributes
2023-02-05 00:32:25 +00:00
Json::Value& attributes = course_term["attributes"];
attributes = Json::arrayValue;
for(;attributes_itr != end_itr
&& !attributes_itr->str().empty();
attributes_itr++) {
handle_attribute(attributes_itr->str(),attributes);
2023-02-04 17:38:37 +00:00
}
}
2023-02-04 22:29:50 +00:00
void handle_attribute(const std::string& attribute,
Json::Value& attributes) {
2023-02-04 17:38:37 +00:00
if(attribute == "Communication Intensive") {
2023-02-04 22:29:50 +00:00
attributes.append("[CI]");
2023-02-04 17:38:37 +00:00
} else if(attribute == "Writing Intensive") {
2023-02-04 22:29:50 +00:00
attributes.append("[WI]");
2023-02-04 17:38:37 +00:00
} else if(attribute == "HASS Inquiry") {
2023-02-04 22:29:50 +00:00
attributes.append("[HInq]");
2023-02-04 17:38:37 +00:00
} else if(attribute == "Culminating Exp/Capstone") {
2023-02-04 22:29:50 +00:00
attributes.append("[CulmExp]");
2023-02-04 17:38:37 +00:00
} else if(attribute == "PDII Option for Engr Majors") {
2023-02-04 22:29:50 +00:00
attributes.append("[PDII]");
2023-02-04 17:38:37 +00:00
}
}