From 09efa8082584c8085aefed4e062780f61fd633d7 Mon Sep 17 00:00:00 2001 From: Jeremy Bowers Date: Tue, 11 Feb 2014 20:52:09 -0500 Subject: [PATCH] Updates scraper. Adds requirements file. Adds license. Adds readme. --- .gitignore | 2 + data/.placeholder | 0 license | 21 +++++++ readme.md | 21 +++++++ requirements.txt | 3 + scrape.py | 153 +++++++++++++++++++++++++++++++++++++++++++--- 6 files changed, 193 insertions(+), 7 deletions(-) create mode 100644 .gitignore create mode 100644 data/.placeholder create mode 100644 license create mode 100644 readme.md create mode 100644 requirements.txt mode change 100644 => 100755 scrape.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4fcc689 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +data/*.html +data/*.json \ No newline at end of file diff --git a/data/.placeholder b/data/.placeholder new file mode 100644 index 0000000..e69de29 diff --git a/license b/license new file mode 100644 index 0000000..b7350d5 --- /dev/null +++ b/license @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 A.J. Walsh + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. \ No newline at end of file diff --git a/readme.md b/readme.md new file mode 100644 index 0000000..ffb1e9b --- /dev/null +++ b/readme.md @@ -0,0 +1,21 @@ +# BIRMINGHAM EATS WELL + +This is a restaurant inspection scraper for Jefferson County, AL. This repository is licensed under the MIT license; see ```license``` for information. + +## Getting started +Clone this repository. +``` +git clone https://github.com/ajwalsh08/Main.git +cd Main +``` + +Make a virtual environment and install requirements. +``` +mkvirtualenv main +pip install -r requirements.txt +``` + +Run the scraper to get the data as a giant JSON file. +``` +./scrape.py +``` \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..23fb03e --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +beautifulsoup4==4.3.2 +requests==2.2.1 +wsgiref==0.1.2 diff --git a/scrape.py b/scrape.py old mode 100644 new mode 100755 index befc3af..3e5b85f --- a/scrape.py +++ b/scrape.py @@ -1,14 +1,153 @@ -from bs4 import BeautifulSoup +#!/usr/bin/env python +import json +import os +from bs4 import BeautifulSoup import requests -url = raw_input("Enter a website from which to extract the URLs:") +html_file = "data/restaurant_list.html" +json_file = "data/restaurant_list.json" +url = "http://www.jcdh.org/EH/FnL/FnL03.aspx" + +def init(): + """ + When we run this file as ./scrape.py, what functions should we call? + """ + + # If the HTML file isn't there, scrape it. + if not os.path.exists(html_file): + scrape_list_html() + + # If the JSON file isn't there, parse the HTML file to make it. + if not os.path.exists(json_file): + parse_list_html() + + # If the JSON file is there, make us a neat summary. + if os.path.exists(json_file): + summarize_inspections() + +def scrape_list_html(): + """ + Might as well have a pair of functions to do our stuff. + Two things we want to do? Scrape html from the site, then parse it for data. + So, this will scrape and download the HTML for the restaurant list. + """ + + data = {} + data["ctl00$ScriptManager1"] = "ctl00$updPnl|ctl00$BodyContent$btnSearch" + data["__LASTFOCUS"] = "" + data["__EVENTTARGET"] = "" + data["__EVENTARGUMENT"] = "" + data["__VIEWSTATE"] = "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" + data["__EVENTVALIDATION"] = "/wEWGAL31/rsAgLH9KHnAgKey+rMAQLHnfaXBALpu6S2DwLfh5bMBQKZl6CuDALkt5etDAKq9NziCQKI6ZSeBwKOoaVkAqvO6GQCnaaG2gICpcT57gEC+sydvwUCvtDMuAUCxOTC9AIC2+ev3A4Cq9H72AYCmJTp8ggC36PWzgMCt5TDogYCvvDiXAK/yv2wA7NIIzqjGrc+LEQqHz5ZKe9OCqr3" + data["ctl00$txtSearch"] = "" + data["ctl00$BodyContent$txtBKeyword"] = "" + data["hiddenInputToUpdateATBuffer_CommonToolkitScripts"] = "1" + data["ctl00$BodyContent$btnSearch"] = "Search" + + headers = {} + headers["Accept"] = "*/*" + headers["Accept-Encoding"] = "gzip,deflate,sdch" + headers["Accept-Language"] = "en-US,en;q=0.8" + headers["Cache-Control"] = "no-cache" + headers["Connection"] = "keep-alive" + headers["Content-Length"] = "45938" + headers["Content-Type"] = "application/x-www-form-urlencoded" + headers["Cookie"] = "ASP.NET_SessionId=qw1wzj32griyyp55ldacth45; LastId=2" + headers["DNT"] = "1" + headers["Host"] = "www.jcdh.org" + headers["Origin"] = "http://www.jcdh.org" + headers["Referer"] = "http://www.jcdh.org/EH/FnL/FnL03.aspx" + headers["User-Agent"] = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1700.107 Safari/537.36" + headers["X-MicrosoftAjax"] = "Delta=true" + + r = requests.post(url, data=data, headers=headers) + + with open(html_file, 'wb') as writefile: + writefile.write(r.content) + +def parse_list_html(): + """ + Now that we've written to a file, read the file and parse the links with BeautifulSoup. + """ + with open(html_file, 'rb') as readfile: + + soup = BeautifulSoup(readfile.read()) + + restaurants = [] + + for row in soup.select('#ctl00_BodyContent_gvFoodScores tr'): + + # Set up a dictionary for storing restaurant data. + restaurant_dict = {} + + try: + + # Start adding stuff to our dictionary. + restaurant_dict['smoking'] = row.select('td')[0].text.strip().encode('utf-8') + restaurant_dict['name'] = row.select('td')[1].text.strip().encode('utf-8') + restaurant_dict['restaurant_type'] = row.select('td')[2].text.strip().encode('utf-8') + restaurant_dict['address'] = row.select('td')[3].text.strip().encode('utf-8') + + # Let's make a little nested dictionary for the latest score. + restaurant_dict['latest_score'] = {} + restaurant_dict['latest_score']['score'] = row.select('td')[4].text.strip().encode('utf-8') + restaurant_dict['latest_score']['date_string'] = row.select('td')[5].text.strip().encode('utf-8') + + """ + The result will look like this: + { + "smoking": "yes", + "name": "Some Restaurant Name", + "url": "http://some.restaurant.url/", + "restaurant_type": "Bars and Lounges", + "latest_score": { + "score": "99", + "url": "http://some.restaurant.url/?id=506", + "date_string": "02/05/2014" + } + } + """ + + restaurants.append(restaurant_dict) + + except IndexError: + # Some restaurants are missing things. We'll skip 'em for now. + print row.select('td') + + # Write the list of restaurants to JSON. + with open(json_file, 'wb') as writefile: + writefile.write(json.dumps(restaurants)) + +def summarize_inspections(): + """ + Let's do a little summary thing. + """ + with open(json_file, 'rb') as readfile: + restaurant_list = list(json.loads(readfile.read())) + + # Get the total number of restaurants. + total_restaurants = len(restaurant_list) + + # Set a score variable. + total_score = 0 + + # Loop over all the restaurants. + for restaurant in restaurant_list: + + try: + + # If this restaurant has a score that is an integer, add it to the total. + total_score += int(restaurant['latest_score']['score']) + + except ValueError: -r = requests.get("http://" + url) + # Otherwise, remove this restaurant from the list. + restaurant_list -= 1 -data = r.text + # The average is the total score / total number of restaurants. + print "Average score: %s" % (total_score / total_restaurants) -soup = BeautifulSoup(data) +if __name__ == "__main__": + init() -for link in soup.find_all('PermitNbr'): - print(link.get('href')) \ No newline at end of file