Planners-GitHub.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This is our notebook for our web scraping code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is where we can add more information about the code we are **running**/*writing*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import librarys required for web scraping tools\n",
    "from bs4 import BeautifulSoup\n",
    "from datetime import datetime, date\n",
    "#import timestring # this is what this has become in Python 3\n",
    "import time\n",
    "import sys\n",
    "from time import strftime\n",
    "#from urllib import urlopen\n",
    "# The help us access the web pages\n",
    "import urllib3\n",
    "import certifi\n",
    "import numpy as np\n",
    "#import os\n",
    "import matplotlib.pyplot as plt\n",
    "#from IPython.display import HTML\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Current offering we are investigating (can be automated)\n",
    "#this it the formatting in the web addresses - check each semester\n",
    "semno = '-S3-'#'-S1-'#'-S2-'\n",
    "semnum = ['-S1-','-S2-','-S3-','-FY']\n",
    "#order of preferred offerings (for course specs)\n",
    "semmode = ['WEB','EXT','ONC'] # Anita these offine (e.g. online?)\n",
    "semonc = ['TWMBA','SPRNG','IPSCH']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what year are we interested in: \n",
    "yr = 2018 # this can be automated at a later time.\n",
    "# We need to set up the path for time tables.  \n",
    "usqpathtime='https://www.usq.edu.au/timetables/' \n",
    "# We need to update if the website changes\n",
    "# We need to set up the path for the course specifications.  \n",
    "usqpathspecs='http://www.usq.edu.au/course/specification/'\n",
    "# course synopsis\n",
    "usqpathgen='http://www.usq.edu.au/course/synopses/'\n",
    "# Read dates (e.g. start of semester) so we don't have to \n",
    "# type them in each semester/time we run the code\n",
    "dateusq = 'https://www.usq.edu.au/current-students/academic/academic-calendar'\n",
    "# To get the course specifications for specific years.\n",
    "usqurl=usqpathspecs+str(yr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Do you want to save files?\n",
    "#Specify directory path here:\n",
    "nowdate=datetime.now()\n",
    "#os.getcwd()+\n",
    "#fname=\"\\\\\"+str(nowdate.strftime(\"%Y%m%d_%H%M\"))+\"\\\\\"+str(yr)+semno+\"\\\\\"\n",
    "fid=str(yr)+semno+str(nowdate.strftime(\"%Y%m%d_%H%M\"))\n",
    "#Do we want to save course lists to txt files?\n",
    "#YES = 1; NO = 0\n",
    "codelist=0 \n",
    "\n",
    "#Do we want to save ASCED to txt file?\n",
    "#YES = 1; NO = 0\n",
    "ASCEDlist=0\n",
    "\n",
    "#How do you want to sort courses?\n",
    "#disciplines = 1 or  referencing system = 2\n",
    "sortby = 1\n",
    "\n",
    "#Do you want to print COURSE TEXT LISTS GRABS (for library stocking)\n",
    "#YES = 1; NO = 0\n",
    "booklist = 0\n",
    "\n",
    "#filter by year level?\n",
    "#FIRST_YEAR = 1; ALL = 0\n",
    "yrlevel=1\n",
    "\n",
    "#What is the last week number in Semester 1?\n",
    "lenSEM01 = 20\n",
    "#What is the last week number in Semester 2?\n",
    "lenSEM02 = 18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialise variables\n",
    "weeknum = []\n",
    "weekdatest = []\n",
    "weektype = []\n",
    "counter = 0\n",
    "allurl = []\n",
    "callurl=[]\n",
    "onccamp=[] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**set up all the fucntions required throughout the code**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def geturl(usqurl):\n",
    "    http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',ca_certs=certifi.where())\n",
    "    page = http.request('GET', usqurl) # import the page we are interested in (e.g. dateusq)\n",
    "    soup = BeautifulSoup(page.data,\"lxml\")\n",
    "    #page=urllib3.urlopen(usqurl)   \n",
    "    #soup = BeautifulSoup(page,\"html\")\n",
    "    tablelnk=soup.find(\"table\", id=\"usqcoursetable\")                \n",
    "    for cxml in tablelnk.find_all('a'):\n",
    "        coursexml=str(cxml.get('href')) \n",
    "        allurl.append(usqurl+\"/\"+coursexml)\n",
    "    return allurl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def geturlcourse(cusqurl):\n",
    "    # page=urllib2.urlopen(cusqurl)\n",
    "    http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',ca_certs=certifi.where())\n",
    "    page = http.request('GET', cusqurl) # import the page we are interested in (e.g. dateusq)\n",
    "    soup = BeautifulSoup(page.data,\"lxml\")\n",
    "    tablelnk=soup.find('table', {'class':'usqoffertable'})\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bins_labels(bins, **kwargs):\n",
    "    bin_w = (max(bins) - min(bins)) / (len(bins)-1)\n",
    "    plt.xticks(np.arange(min(bins)+bin_w/2, max(bins)+2, bin_w), bins, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#course texts capture information for LIBRARY \n",
    "booktype=[\"textmaterials\",\"referencematerials\"]\n",
    "#keep double inverted commas and square brackets      \n",
    "booksty=[[\"BK01\"], [\"OT01\"], [\"EB01\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#course discipline information(broadly speaking - more refinements later)\n",
    "engdscp=[\"School of Civil Engineering and Surveying\",\"School of Mechanical and Electrical Engineering\",\"School of Agric, Comp and Environ Sciences\"]              \n",
    "mgtcomlawdscp=[\"School of Law and Justice\",\"School of Commerce\",\"School of Management and Enterprise\"]\n",
    "heawblscidscp=[\"School of Nursing and Midwifery\",\"School of Psychology and Counselling\",\"School of Health and Wellbeing\"]\n",
    "artcommndscp=[\"School of Arts and Communication\",\"Open Access College\",\"Coll for Indigenous Studies, Education & Research\"]\n",
    "CISERspec=[\"ANT3006\"]\n",
    "edudscp=[\"School of Linguistics, Adult and Specialist Educ\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#library referencing sorting information (broadly speaking - more refinements later)\n",
    "APAcode=[\"School of Nursing and Midwifery\",\"School of Psychology and Counselling\",\"School of Health and Wellbeing\",\"School of Arts and Communication\",\"Open Access College\",\"Coll for Indigenous Studies, Education & Research\",\"School of Linguistics, Adult and Specialist Educ\",\"School of Agric, Comp and Environ Sciences\"]        \n",
    "Harvardcode=[\"School of Commerce\",\"School of Management and Enterprise\",\"School of Civil Engineering and Surveying\",\"School of Mechanical and Electrical Engineering\"]          \n",
    "AGLCcode=[\"School of Law and Justice\"]   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#assessment types\n",
    "rmvatype=[\"Quiz\",\"QUIZ\",\"Online\", \"On Line\",\"CMA\", \"On line\", \"ONLINE\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#page = urllib3.urlopen(dateusqurl)\n",
    "http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',ca_certs=certifi.where())\n",
    "page = http.request('GET', dateusq) # import the page we are interested in (e.g. dateusq)\n",
    "soup = BeautifulSoup(page.data,\"lxml\")\n",
    "\n",
    "#print(soup) # returns the raw html for scraping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# looking for specific information on the webpage\n",
    "tablelnk3=soup.find('table', attrs={'class':'table table-striped'})\n",
    "# print(tablelnk3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "for td_tag in tablelnk3.find_all('td'):\n",
    "# print td_tag.string\n",
    "    if td_tag.string != None:\n",
    "    # print td_tag.string\n",
    "        if counter%3 == 0:\n",
    "            weeknum.append(td_tag.string)\n",
    "        elif counter%3 == 1:\n",
    "            weekdatest.append(td_tag.string) \n",
    "        elif counter%3 == 2:\n",
    "            weektype.append(td_tag.string)  \n",
    "    counter+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# spliting the strings\n",
    "# need to find the first week of semester! (or other interesting week)\n",
    "# worduniweek0 = weekdatest[0].split('-', 1 )[0]\n",
    "# print(worduniweek0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "worduniweek0 = weekdatest[0].split('-', 1 )[0]\n",
    "worduniweek0 = worduniweek0.encode('ascii', 'ignore').decode('ascii')\n",
    "#print('first week of semester 1: '+worduniweek0+' '+str(yr))\n",
    "     \n",
    "week0full=datetime.strptime(worduniweek0+' '+str(yr), '%d %b %Y')        \n",
    "#print('computer format: ')\n",
    "#print(week0full)\n",
    "        \n",
    " # fulldatewk0=datetime.strptime(week0full,\"%Y-%m-%d\")\n",
    "# check this every year\n",
    "#SEMESTER 1 WEEK NUMBER\n",
    "startwk = datetime.date(week0full).isocalendar()[1]\n",
    "#print('Week of the calendar year: ')\n",
    "#print(startwk)\n",
    "\n",
    "#find maximum week number in year (for adjustments in S3)\n",
    "#by ISO standards, last week of year ALWAYS has 28 December in it\n",
    "findmaxwkno = date(yr, 12, 28)\n",
    "maxwkno = findmaxwkno.isocalendar()[1]\n",
    "\n",
    "# raise SystemExit(0) # <- kill switch for the code\n",
    "oldcode = \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#fulldatewk0 = datetime.strptime(week0full,\"%Y-%m-%d\")\n",
    "#print(fulldatewk0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set up the other start of the other semesters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to find the maximum week number each year\n",
    "maxwkno = int(strftime(\"%U\",time.strptime(\"31 Dec \"+str(yr), \"%d %b %Y\")))\n",
    "#print(maxwkno)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using urllib3 to get pages\n",
    "#http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',ca_certs=certifi.where())\n",
    "#page = http.request('GET', dateusq) # import the page we are interested in (e.g. dateusq)\n",
    "#soup = BeautifulSoup(page.data,\"lxml\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "allurl=geturl(usqurl)\n",
    "exceptcount=0\n",
    "#print(allurl)\n",
    "# type(allurl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## This is where we are up to! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[*****************************************************************************************************] 99.9% \r"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "This is now working and takes a long time to run (not an error). -> CHECK OUT THE PROGRESS BAR\n",
    "this is finding the table classes to pull out the offerings!\n",
    "\"\"\"\n",
    "\n",
    "#need to remove all the urllib2 referencs!!!! (Don't run yet!!!!!)\n",
    "# curl stands for counter for the URLs\n",
    "\n",
    "for curl in range(len(allurl)):  \n",
    "    #sometimes you may run this code while the specification are being updated, or the websites have crashed.\n",
    "    #the try and exception here is to alert you to any individual specifications which may be affected.\n",
    "    try:\n",
    "        http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',ca_certs=certifi.where())\n",
    "        page = http.request('GET', allurl[curl])       \n",
    "        soup = BeautifulSoup(page.data,\"xml\") \n",
    "        # tablelnk=soup.find('table', {'class':'usqoffertable table'})     \n",
    "        tablelnk=soup.find('table', {'class':'table table-striped linkedtable'})\n",
    "        #print(tablelnk)\n",
    "        for cxml in tablelnk.find_all('a'): \n",
    "            rowshtml=str(cxml.get('href')) \n",
    "            htmlcode0=rowshtml.split('../../specification/'+str(yr)+'/', 1 )[1]\n",
    "            htmlcode1=htmlcode0.split('-', 1 )[0]\n",
    "            if oldcode==\"\": oldcode= htmlcode1 \n",
    "            newcode=htmlcode1\n",
    "            if (onccamp!=[] and any(newcode in x1 for x1 in onccamp)) or (onccamp==[]):\n",
    "                onccamp.append(usqurl+\"/\"+rowshtml)\n",
    "                # print(onccamp)\n",
    "            elif onccamp!=[] and not any(newcode in x1 for x1 in onccamp):                   \n",
    "                try:\n",
    "                    #this creates a list of possible course offerings in this order of preference \n",
    "                    #1: TWMBA - WEB\n",
    "                    #2: TWMBA - EXT\n",
    "                    #3: TWMBA - ONC\n",
    "                    #4: SPR - ONC\n",
    "                    #5: IPS - ONC\n",
    "                    preflist=[oldcode, next(val for val in semnum if (any(val in x for x in onccamp))and val==semno), next(val2 for val2 in semmode if any(val2 in x2 for x2 in onccamp)),next(val3 for val3 in semonc if any(val3 in x3 for x3 in onccamp))]                  \n",
    "                    # print(preflist) \n",
    "                except:  \n",
    "                    #this is a non event\n",
    "                    semnum\n",
    "                # KEEP THIS     #KEEP THIS     #KEEP THIS     #KEEP THIS     #KEEP THIS     #KEEP THIS     #KEEP THIS     #KEEP THIS     #KEEP THIS            \n",
    "                # print(oldcode, [val for val in onccamp  if all(x in val in onccamp for x in preflist)])\n",
    "                # KEEP THIS     #KEEP THIS     #KEEP THIS     #KEEP THIS     #KEEP THIS     #KEEP THIS     #KEEP THIS  \n",
    "                if semno in preflist:\n",
    "                    callurl.extend([val for val in onccamp  if all(x in val in onccamp for x in preflist)])\n",
    "                onccamp=[]                   \n",
    "                onccamp.append(usqurl+\"/\"+rowshtml)                        \n",
    "        # print(onccamp)  \n",
    "        oldcode=newcode\n",
    "        \n",
    "        #PROGRESS BAR\n",
    "        alltime=101\n",
    "\n",
    "        sofar = int(round(alltime * curl / float(len(allurl))))\n",
    "        percents = round(100.0 * curl / float(len(allurl)), 1)\n",
    "        bar = '*' * sofar + '.' * (alltime - sofar)\n",
    "        sys.stdout.write('[%s] %s%s \\r' % (bar, percents, '%'))\n",
    "        sys.stdout.flush() \n",
    "                \n",
    "    except:\n",
    "        continue\n",
    "        exceptcount=+1\n",
    "        if exceptcount>3:\n",
    "            #try again later = after close of business \n",
    "            print(\"Code aborted due to large number of unavailable specification pages.  Please try again later.\")\n",
    "            break\n",
    "        else:\n",
    "            continue       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.] 99.5% \r"
     ]
    }
   ],
   "source": [
    "code3letall = []\n",
    "coursecodeall = []\n",
    "gencourseinfo = []\n",
    "ccfacsect = []\n",
    "ccdscpln = []\n",
    "ccASCEDall = []\n",
    "ASCEDcc = []\n",
    "wght = []\n",
    "typeass = []\n",
    "coursecodedue = []\n",
    "ccdscplndue = []\n",
    "duedate = []\n",
    "duewknum = []\n",
    "duewkuni = []\n",
    "\n",
    "#LIB BOOKS\n",
    "coursetxtinfo=[]\n",
    "ctitletxt = []\n",
    "coursecode4txt = []\n",
    "bktype=[]\n",
    "LIBTxTBK = []\n",
    "#course code features\n",
    "strlen=7\n",
    "codelen=3\n",
    "\n",
    "for curl2 in range(len(callurl)): \n",
    "    cusq = callurl[curl2]\n",
    "    #print(cusq)\n",
    "    start=cusq.find('-S'or'-Y')-strlen\n",
    "    coursecode=cusq[start:start+strlen]\n",
    "    #3 letter code only\n",
    "    code3let=cusq[start:start+codelen]\n",
    "    if code3let not in code3letall:\n",
    "        code3letall.append(code3let)\n",
    "    coursecodeall.append(coursecode)  \n",
    "    #print(coursecodeall)\n",
    "    try:\n",
    "        gencourseinfo.append(usqpathgen+str(yr)+\"/\"+coursecode+\".html\")\n",
    "    except:\n",
    "        print(str(usqpathgen+str(yr)+\"/\"+coursecode+\".html\"))\n",
    "    updccodethmlist=1 \n",
    "    #these lines below may be needed to be updated \n",
    "    #This retrieves ASCED codes and course sorting information \n",
    "    if updccodethmlist==1:\n",
    "        http2 = urllib3.PoolManager(cert_reqs = 'CERT_REQUIRED',ca_certs = certifi.where())\n",
    "        page2 = http2.request('GET', gencourseinfo[curl2])\n",
    "        soup2 = BeautifulSoup(page2.data,'xml')\n",
    "        getinfo = soup2.findAll('tr')[2].findAll('td')\n",
    "        for td_tag2 in getinfo:\n",
    "            if ('Faculty or Section :' not in td_tag2.text):\n",
    "                ccfac = td_tag2.text\n",
    "                ccfacsect.append(ccfac)\n",
    "                \n",
    "        getinfo = soup2.findAll('tr')[3].findAll('td')\n",
    "        for td_tag2 in getinfo:\n",
    "            if ('School or Department :' not in td_tag2.text):\n",
    "                ccdscp = td_tag2.text\n",
    "                ccdscpln = [].append(ccdscp) \n",
    "\n",
    "        getinfo = soup2.findAll('tr')[5].findAll('td')\n",
    "        for td_tag2 in getinfo:\n",
    "            if ('ASCED code :' not in td_tag2.text):\n",
    "                ccASCED = td_tag2.text\n",
    "                ccASCEDall.append(str(ccASCED)) \n",
    "    ASCEDcc.append(str(coursecode)+ '; ' + str(ccASCED)+ '; ' + str(ccdscp) + '; ' + str(ccfac))     \n",
    "    \n",
    "    #this retrieves assessment due dates\n",
    "    http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',ca_certs=certifi.where())\n",
    "    cpage = http.request('GET', callurl[curl2])\n",
    "    casssoup = BeautifulSoup(cpage.data,\"html\") \n",
    "    #print(casssoup) \n",
    "    casstablnk=casssoup.find('div', {'id':'assessmentdetails'})\n",
    "    indexcount=0\n",
    "    tagcount=0\n",
    "    if casstablnk != None:\n",
    "        for th_tag in casstablnk.find_all('th'):\n",
    "            indexcount += 1\n",
    "            if \"Wtg\" in th_tag.text:\n",
    "                indxWtg = indexcount\n",
    "            if \"Description\" in th_tag.text:\n",
    "                indxAsmt = indexcount\n",
    "        for td_tag in casstablnk.find_all('td'):\n",
    "            tagcount += 1\n",
    "            if tagcount % indexcount == indxWtg:\n",
    "                wghtasg = td_tag.text\n",
    "            if tagcount % indexcount == indxWtg:\n",
    "                typeasg = td_tag.text\n",
    "            if str(yr) in td_tag.text or str(yr+1) in td_tag.text or str(yr-1) in td_tag.text:\n",
    "                wght.append(wghtasg)\n",
    "                typeass.append(typeasg)\n",
    "                coursecodedue.append(coursecode)\n",
    "                ccdscplndue.append(ccdscp)\n",
    "                duedate.append(td_tag.text)\n",
    "                if semno == '-S1-':\n",
    "                    duewkuni = int(strftime('%U',time.strptime(td_tag.text, '%d %b %Y')))- startwk + 1\n",
    "                    #print(coursecode, \": Date =\",td_tag.text, \"& Wk:\", duewkuni)#<- run this to check that wk numbers match up with academic calendar\n",
    "                elif semno == '-S2-':\n",
    "                    duewkuni = int(strftime('%U',time.strptime(td_tag.text, '%d %b %Y')))- startwk + 1 - lenSEM01\n",
    "                    #print(coursecode, \": Date =\",td_tag.text, \"& Wk:\", duewkuni)#<- run this to check that wk numbers match up with academic calendar\n",
    "                elif semno == '-S3-':\n",
    "                    duewkuni = int(strftime('%U',time.strptime(td_tag.text, '%d %b %Y'))) - startwk + 1 - (lenSEM01 + lenSEM02) +1\n",
    "                    if duewkuni <0:    \n",
    "                        duewkuni = duewkuni + maxwkno\n",
    "                    #print(coursecode, \": Date =\",td_tag.text, \"& Wk:\", duewkuni)#<- run this to check that wk numbers match up with academic calendar        \n",
    "                duewknum.append(duewkuni)        \n",
    "    else:\n",
    "        wght.append(\"100\")\n",
    "        typeass.append(\"Assignment\")\n",
    "        coursecodedue.append(coursecode)\n",
    "        ccdscplndue.append(ccdscp)\n",
    "        duedate.append(\"TBA\")\n",
    "        duewknum.append(duewkuni)\n",
    "    \n",
    "    #COURSE TEXT LISTS GRABS (for library stocking)\n",
    "    if booklist == 1:\n",
    "        bksoup = BeautifulSoup(cpage.data,\"html\") \n",
    "        #print(bksoup) \n",
    "        for bt in range(len(booktype)):\n",
    "            for txtmat in bksoup.find_all('div', {'class': booktype[bt]}):\n",
    "                txtmat_desc=txtmat.descendants\n",
    "                for d in txtmat_desc:\n",
    "                    if txtmat_desc != None:\n",
    "                        if d.name == 'div' and d.get('class','') in booksty:\n",
    "                            #print(d.text)\n",
    "                            cbkinfo=d.text\n",
    "                            coursetxtinfo.append(d.text)\n",
    "                        if d.name == 'i' and d.get('class','') == ['title']:\n",
    "                            titlebk=d.text\n",
    "                            ctitletxt.append(titlebk)\n",
    "                            coursecode4txt.append(coursecode)\n",
    "                            booktypestr=booktype[bt]\n",
    "                            bktype.append(booktypestr)                                \n",
    "                            #print(d.text) \n",
    "                        else:\n",
    "                            titlebk=\"\"\n",
    "                LIBTxTBK.append(str(coursecode) + '; ' + str(booktypestr) + '; ' + str(titlebk) + '; ' + str(cbkinfo))                            \n",
    "    \n",
    "    #PROGRESS BAR\n",
    "    alltime=101\n",
    "    sofar = int(round(alltime * curl2 / float(len(callurl))))\n",
    "    percents = round(100.0 * curl2 / float(len(callurl)), 1)\n",
    "    bar = 'X' * sofar + '.' * (alltime - sofar)\n",
    "    sys.stdout.write('[%s] %s%s \\r' % (bar, percents, '%'))\n",
    "    sys.stdout.flush() \n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#prep for histograms (disciplines)\n",
    "histvalmatWk=[]\n",
    "histvalHDRWk=[]\n",
    "histvalEDUWk=[]\n",
    "histvalENGBENVITWk=[]\n",
    "histvalMGTCOMLAWWk=[]\n",
    "histvalARTCOMMNWk=[]\n",
    "histvalHEAWBLSCIWk=[]  \n",
    "             \n",
    "histcstartmatWk=[]\n",
    "histcstartHDRWk=[]\n",
    "histcstartEDUWk=[]\n",
    "histcstartENGBENVITWk=[]\n",
    "histcstartMGTCOMLAWWk=[]\n",
    "histcstartARTCOMMNWk=[]\n",
    "histcstartHEAWBLSCIWk=[] \n",
    "\n",
    "#prep for course code txt lists (disciplines)\n",
    "mathcodelist=[]\n",
    "hdrcodelist=[]\n",
    "heawblscilist=[]\n",
    "engbenvitlist=[]\n",
    "mgtcomlawlist=[]\n",
    "artcommnlist=[]\n",
    "educodelist=[]\n",
    "\n",
    "plotduewkno=[]\n",
    "\n",
    "#prep for histograms (referencing styles)      \n",
    "histvalAPAWk=[]\n",
    "histvalHarvardWk=[]\n",
    "histvalAGLCWk=[] \n",
    "\n",
    "histcstartAPAWk=[]\n",
    "histcstartHarvardWk=[]\n",
    "histcstartAGLCWk=[]     \n",
    "\n",
    "#prep for course code txt lists (referencing styles)\n",
    "APAcodelist=[]\n",
    "Harvardcodelist=[]        \n",
    "AGLCcodelist=[] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "for indexnum, (wknum,codeno,ccdscpl,wno,typelab) in enumerate(zip(duewknum,coursecodedue,ccdscplndue,wght,typeass)):\n",
    "#first year courses, include this term     -->   #and codeno[3]==\"1\"\n",
    "    if yrlevel == 1: \n",
    "        codeyr=[\"1\",\"2\"]\n",
    "    elif yrlevel == 0: #ALL \n",
    "        codeyr=[\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\"]\n",
    "        #if sorting by [1]\n",
    "    if sortby == 1:\n",
    "        if ((codeno[3] in codeyr)and(codeno[0:3]==\"MAT\" or codeno[0:3]==\"ENM\"  or codeno[0:3]==\"STA\" or codeno[0:6]==\"TPP718\" or codeno[0:7]==\"TPP7160\"or codeno[0:6]==\"EAP738\" or codeno[0:7]==\"DIP1003\"or codeno[0:7]==\"DIP1004\")):  \n",
    "                histvalmatWk.append(indexnum)\n",
    "                mathcodelist.append(codeno)\n",
    "                plotduewkno.append(wknum)\n",
    "  \n",
    "        elif ((codeno[3] in codeyr)and(codeno[3]==\"9\" or codeno[0:3]==\"WRP\"or codeno[0:3]==\"RES\" or ((codeno[3]==\"8\" or codeno[3]==\"9\") and (codeno[0:3]==\"SCI\" or codeno[0:3]==\"EDR\" or codeno[0:3]==\"BUS\"or codeno[0:3]==\"MSC\")))\n",
    "                and not any(x in typelab for x in rmvatype)):                    \n",
    "                histvalHDRWk.append(indexnum)\n",
    "                hdrcodelist.append(codeno)\n",
    "                plotduewkno.append(wknum)\n",
    "                \n",
    "        elif ((codeno[3] in codeyr)and(codeno[0:2]==\"ED\" or ccdscpl in edudscp) and not any(x in typelab for x in rmvatype)):\n",
    "                histvalEDUWk.append(indexnum)\n",
    "                educodelist.append(codeno)\n",
    "                plotduewkno.append(wknum)\n",
    "                    \n",
    "        elif ((codeno[3] in codeyr)and(ccdscpl in engdscp or codeno[0:3]==\"ENG\" or codeno[0:3]==\"CIS\"or codeno[0:3]==\"CSC\") and not any(x in typelab for x in rmvatype)):\n",
    "                histvalENGBENVITWk.append(indexnum)\n",
    "                engbenvitlist.append(codeno)\n",
    "                plotduewkno.append(wknum)\n",
    "\n",
    "        elif ((codeno[3] in codeyr)and(ccdscpl in heawblscidscp)):# and not any(x in typelab for x in rmvatype)):\n",
    "                histvalHEAWBLSCIWk.append(indexnum)\n",
    "                heawblscilist.append(codeno)\n",
    "                plotduewkno.append(wknum)\n",
    "\n",
    "        elif ((codeno[3] in codeyr)and((ccdscpl in artcommndscp) or (codeno[0:3]==\"IPP\" or codeno[0:3]==\"ISE\" or codeno[0:3]==\"KNL\") or codeno in CISERspec) and not any(x in typelab for x in rmvatype)):\n",
    "                histvalARTCOMMNWk.append(indexnum)\n",
    "                artcommnlist.append(codeno)\n",
    "                plotduewkno.append(wknum)\n",
    "\n",
    "        elif ((codeno[3] in codeyr)and(ccdscpl in mgtcomlawdscp) and not any(x in typelab for x in rmvatype)):\n",
    "                histvalMGTCOMLAWWk.append(indexnum)\n",
    "                mgtcomlawlist.append(codeno)\n",
    "                plotduewkno.append(wknum)\n",
    "    elif sortby == 2:       \n",
    "        if ((ccdscpl in APAcode) or (codeno[0:3]==\"AVN\") ):# and not any(x in typelab for x in rmvatype)):\n",
    "                histvalAPAWk.append(indexnum)\n",
    "                APAcodelist.append(codeno)\n",
    "                plotduewkno.append(wknum)\n",
    "        elif ((ccdscpl in Harvardcode) and not (codeno[0:3]==\"AVN\") ):# and not any(x in typelab for x in rmvatype)):\n",
    "                histvalHarvardWk.append(indexnum)\n",
    "                Harvardcodelist.append(codeno)\n",
    "                plotduewkno.append(wknum)\n",
    "        elif ((ccdscpl in AGLCcode)):# and not any(x in typelab for x in rmvatype)):\n",
    "                histvalAGLCWk.append(indexnum)\n",
    "                AGLCcodelist.append(codeno)\n",
    "                plotduewkno.append(wknum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#writing lists of courses to files\n",
    "if ASCEDlist == 1:\n",
    "    fASCEDpath=\"ASCEDcc_\"+fid+\".txt\"  \n",
    "    fASCEDcode = open(fASCEDpath, \"w\")\n",
    "    fASCEDcode.write(\"\\n\".join(map(lambda x: str(x), ASCEDcc)))\n",
    "    fASCEDcode.close()       \n",
    "        \n",
    "if codelist == 1:    \n",
    "    if sortby == 1:\n",
    "        #write lists to files (disciplines)        \n",
    "        setmathcodelist=set(mathcodelist)\n",
    "        fmathpath=\"mathcodelist_\"+fid+\".txt\"\n",
    "        #fmath = open(\"mathcodelist_2017S2.txt\", \"w\")\n",
    "        fmath = open(fmathpath, \"w\")\n",
    "        fmath.write(\"\\n\".join(map(lambda x: str(x), setmathcodelist)))\n",
    "        fmath.close()\n",
    "\n",
    "        sethdrcodelist=set(hdrcodelist)        \n",
    "        fhdrpath=\"hdrcodelist_\"+fid+\".txt\"         \n",
    "        #fhdr = open(\"hdrcodelist_2017S2.txt\", \"w\")\n",
    "        fhdr = open(fhdrpath, \"w\")\n",
    "        fhdr.write(\"\\n\".join(map(lambda x: str(x), sethdrcodelist)))\n",
    "        fhdr.close()\n",
    "\n",
    "        seteducodelist=set(educodelist)\n",
    "        fedupath=\"educodelist_\"+fid+\".txt\"  \n",
    "        #fedu = open(\"educodelist_2017S2.txt\", \"w\")\n",
    "        fedu = open(fedupath, \"w\")\n",
    "        fedu.write(\"\\n\".join(map(lambda x: str(x), seteducodelist)))\n",
    "        fedu.close()\n",
    "        \n",
    "        setengbenvitlist=set(engbenvitlist)\n",
    "        fengitpath=\"engbenvitlist_\"+fid+\".txt\"  \n",
    "        #fengit = open(\"engbenvitlist_2017S2.txt\", \"w\")\n",
    "        fengit = open(fengitpath, \"w\")\n",
    "        fengit.write(\"\\n\".join(map(lambda x: str(x), setengbenvitlist)))\n",
    "        fengit.close()\n",
    "\n",
    "        setartcommnlist=set(artcommnlist)\n",
    "        fcomartpath=\"artcommnlist_\"+fid+\".txt\"  \n",
    "        #fcomart = open(\"artcommnlist_2017S2.txt\", \"w\")\n",
    "        fcomart = open(fcomartpath, \"w\")\n",
    "        fcomart.write(\"\\n\".join(map(lambda x: str(x), setartcommnlist)))\n",
    "        fcomart.close()\n",
    "\n",
    "        setmgtcomlawlist=set(mgtcomlawlist)\n",
    "        fbusmanpath=\"mgtcomlawlist_\"+fid+\".txt\"  \n",
    "        #fbusman = open(\"mgtcomlawlist_2017S2.txt\", \"w\")\n",
    "        fbusman = open(fbusmanpath, \"w\")\n",
    "        fbusman.write(\"\\n\".join(map(lambda x: str(x), setmgtcomlawlist)))\n",
    "        fbusman.close()\n",
    "        \n",
    "        setheawblscilist=set(heawblscilist)\n",
    "        fsciheapath=\"heawblscilist_\"+fid+\".txt\"  \n",
    "        #fscihea = open(\"heawblscilist_2017S2.txt\", \"w\")\n",
    "        fscihea = open(fsciheapath, \"w\")\n",
    "        fscihea.write(\"\\n\".join(map(lambda x: str(x), setheawblscilist)))\n",
    "        fscihea.close()\n",
    "        \n",
    "    elif sortby == 2:        \n",
    "        \n",
    "        setAPAcodelist=set(APAcodelist)        \n",
    "        fAPApath=\"APAcodelist_\"+fid+\".txt\"        \n",
    "        fAPA = open(fAPApath, \"w\")\n",
    "        fAPA.write(\"\\n\".join(map(lambda x: str(x), setAPAcodelist)))\n",
    "        fAPA.close()\n",
    "        \n",
    "        setHarvardcodelist=set(Harvardcodelist)        \n",
    "        fHarvardpath=\"Harvardcodelist_\"+fid+\".txt\"        \n",
    "        fHarvard = open(fHarvardpath, \"w\")\n",
    "        fHarvard.write(\"\\n\".join(map(lambda x: str(x), setHarvardcodelist)))\n",
    "        fHarvard.close()\n",
    "\n",
    "        setAGLCcodelist=set(AGLCcodelist)        \n",
    "        fHarvardpath=\"AGLCcodelist_\"+fid+\".txt\"        \n",
    "        fAGLC = open(fHarvardpath, \"w\")\n",
    "        fAGLC.write(\"\\n\".join(map(lambda x: str(x), setAGLCcodelist)))\n",
    "        fAGLC.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#write library book lists\n",
    "if booklist == 1:\n",
    "        fLibTXTpath=\"CourseTexts_\"+fid+\".txt\"  \n",
    "        fLibTXTcode = open(fLibTXTpath, \"w\")\n",
    "        fLibTXTcode.write(\"\\n\".join(map(lambda x: str(x), LIBTxTBK)))\n",
    "        fLibTXTcode.close() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "#prepare histogram data\n",
    "if sortby==1:                \n",
    "    histcstartmatWk=[duewknum[i] for i in histvalmatWk]\n",
    "    histcstartHDRWk=[duewknum[i] for i in histvalHDRWk]\n",
    "    histcstartHEAWBLSCIWk=[duewknum[i] for i in histvalHEAWBLSCIWk]\n",
    "    histcstartEDUWk=[duewknum[i] for i in histvalEDUWk]        \n",
    "    histcstartARTCOMMNWk=[duewknum[i] for i in histvalARTCOMMNWk]\n",
    "    histcstartMGTCOMLAWWk=[duewknum[i] for i in histvalMGTCOMLAWWk]\n",
    "    histcstartENGBENVITWk=[duewknum[i] for i in histvalENGBENVITWk]\n",
    "\n",
    "elif sortby==2:            \n",
    "    histcstartAPAWk=[duewknum[i] for i in histvalAPAWk]\n",
    "    histcstartHarvardWk=[duewknum[i] for i in histvalHarvardWk]\n",
    "    histcstartAGLCWk=[duewknum[i] for i in histvalAGLCWk]   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x1280 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot histogram\n",
    "fig=plt.figure(figsize=(18, 16), dpi= 80, facecolor='w', edgecolor='k')\n",
    "sub1 = fig.add_subplot(111)\n",
    "fsz=18   \n",
    "if yrlevel==0:\n",
    "    histtitle=\"All Courses\\' Assessment \"+semno[1:-1]+\", \"+str(yr)\n",
    "elif yrlevel == 1:    \n",
    "    histtitle=\"First Year Courses\\' Assessment \"+semno[1:-1]+\", \"+str(yr)\n",
    "sub1.set_title(histtitle,size=fsz+5)\n",
    "graphbins=[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18] \n",
    "\n",
    "#awkcount=np.zeros(len(graphbins))        \n",
    "##find max number of assignments in wk (overall)    \n",
    "#for awk in range (len(graphbins)):\n",
    "#    awkcount[awk]=np.shape(np.where(np.asarray(duewknum) == graphbins[awk]))[-1]\n",
    "#create a dictionary which determines number of assessments due each week \n",
    "#first sort the array\n",
    "d = {x:plotduewkno.count(x) for x in plotduewkno}\n",
    "awknum, adue = d.keys(), d.values()\n",
    "\n",
    "if sortby==1:   \n",
    "    datacourse=[histcstartmatWk,histcstartHDRWk,histcstartEDUWk,histcstartENGBENVITWk,histcstartMGTCOMLAWWk,histcstartARTCOMMNWk,histcstartHEAWBLSCIWk]\n",
    "    legendlst=[\"MATH\", \"HDR\", \"EDU\", \"ENGBENVIT\", \"MGTCOMLAW\", \"ARTCOMMN\",\"HEAWBLSCI\"]         \n",
    "elif sortby==2: \n",
    "    datacourse=[histcstartAPAWk,histcstartHarvardWk,histcstartAGLCWk]            \n",
    "    legendlst=[\"APA\", \"Harvard\", \"AGLC\"]    \n",
    "    #print(datacourse)\n",
    "\n",
    "n1,bins1,patches=sub1.hist(datacourse,bins=graphbins, stacked=True)            \n",
    "plt.legend(legendlst,loc='upper left',prop={'size': fsz})       \n",
    "plt.axis([0, max(graphbins), 0, max(adue)+1])\n",
    "bins_labels(graphbins, fontsize=fsz)\n",
    "plt.yticks(size=fsz)\n",
    "plt.xlabel(\"Teaching Week Number\",size=fsz+2)\n",
    "plt.ylabel(\"Number of Courses\",size=fsz+2)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}