path: root/app.py

from flask import Flask, render_template, redirect, request, url_for, jsonify
from utils import get_closest, translate_to_attr, get_style_preds, translate_to_style
import json
import string
import random
import re
import html
from utils import get_drinks_like
from collections import defaultdict

app = Flask(__name__)

with open("./data/beer_info_small.json") as beers_json:
    beer = json.loads(beers_json.read())


with open('./data/name_list.json') as f:
    name_list = json.load(f)


beers_for_random = [b for b in beer if beer[b][3] > 75]

with open('./data/brewery_names.json') as f:
    brewery_names = json.load(f)
    # brewery_ids = {}
    # for id, name in brewery_names.items():
    #     brewery_ids[name] = id

valid_names = set()
# # beer_ids = {}
for beer_id, vals in beer.items():
    valid_names.add(brewery_names[beer_id.split('-')[0]] + ' — ' + vals[0])

orig_terms = list([x for x in name_list.keys() if x in valid_names])

search_words = [''.join(f for f in x.lower() if f not in string.punctuation) for x in orig_terms]

orig_term_map = dict(zip(search_words, orig_terms))




ATTRS = ['Barnyardy',
 'Bitter',
 'Boozy',
 'Bready',
 'Burnt',
 'Dank',
 'Dark',
 'Dry',
 'Floral',
 'Fruity',
 'Grassy',
 'Herbal',
 'Hoppy',
 'Juicy',
 'Light',
 'Malty',
 'Roasty',
 'Salty',
 'Smoky',
 'Sour',
 'Spicy',
 'Sweet',
 'Thin',
 'Warming',
 'Wheaty',
 'Woody',
 'Yeasty']


@app.route('/')
def index():
    return render_template('Homepage.jinja2')


@app.route('/random')
def random_beer():
    rando = random.choice(list(beers_for_random)).split('-')
    return redirect(url_for('get_beer_details', brewery_id=rando[0], beer_id=rando[1]))


@app.route('/brewery/<brewery_id>/<beer_id>', methods=['GET', 'POST'])
def get_beer_details(brewery_id, beer_id):
    result, brewery_name = beer_lookup(brewery_id, beer_id)
    full_id = brewery_id+'-'+beer_id
    beerinfo = BeerInfo(full_id, brewery_name, result)

    similar_beers = get_closest(full_id)

    style_map = get_style_preds(full_id)
    print('Style Map:{}'.format(style_map))
    similar_beer_objects = []
    for item in similar_beers:
        item_result, item_brewer = beer_lookup(item)
        similar_beer_objects.append(BeerInfo(item, item_brewer, item_result))

    kwargs = {
            "beer_data": beerinfo,
            "attrs": ATTRS,
            "similar_beers": similar_beer_objects,
            "style_preds": similar_beers,
            "style_map": style_map
            }

    if request.method == 'POST':
        attr = request.form.get('attr')
        direction = request.form.get('direction')
        style = request.form.get('style')
        if attr != None and direction != None:
            kwargs['attr'] = attr
            kwargs['direction'] = direction
            attr_beers = translate_to_attr(full_id, attr, directionValue(direction))
            attr_beer_objects = []
            for item in attr_beers:
                item_result, item_brewer = beer_lookup(item[0])
                attr_beer_objects.append(BeerInfo(item[0], item_brewer, item_result))
            kwargs['attr_beers'] = attr_beer_objects
        elif style != None:
            kwargs['style'] = style
            style_beers = translate_to_style(full_id, style)
            style_beer_objects = []
            for item in style_beers:
                item_result, item_brewer = beer_lookup(item[0])
                style_beer_objects.append(BeerInfo(item[0], item_brewer, item_result))
            kwargs['style_beers'] = style_beer_objects

    return render_template('beerpage.jinja2', **kwargs)

def directionValue(name):
    if name == 'Much more':
        return 3
    if name == 'More':
        return 2
    if name == 'Slightly more':
        return 1
    return 0

@app.route('/all_beers.json')
def get_all_beers():
    q = request.args.get('q')
    if not q:
        return redirect('/')

    return jsonify([orig_term_map[x] for x in search_term(q)])
    # return jsonify(names[0:20])

@app.route('/search', methods=['POST'])
def search():
    try:
        q = request.form.get('q')
        if not q:
            return redirect('/')
        q = html.escape(q)
        brewery, beer_name = q.split(' — ')
        print('SEARCHING: ', q)
        beer_id, brewery_id = name_list[q].split('-')
        return redirect(url_for('get_beer_details', beer_id=beer_id, brewery_id=brewery_id))
    except:
        return redirect('/')



def search_term(query):
    query = query.lower()
    query = ''.join(x for x in query if x not in string.punctuation)
    print(query)
    split_query = query.split(' ')
    all_matches = defaultdict(int)
    for term in split_query:
        matches = [x for x in search_words if term in x]
#         print(matches)
        for m in matches:
            if m in all_matches:
                all_matches[m] += .05
            
            all_matches[m] += (1/len(matches))
    print(all_matches)
    return sorted(all_matches, key=lambda x: all_matches[x], reverse=True)[:10]


def beer_lookup(brewery_id, beer_id=None):
    if beer_id:
        item_id = brewery_id + "-" + beer_id
        print(item_id)
        try:
            beer_result = beer[item_id]
            return beer_result, brewery_names[brewery_id]
        except:
            return None
    else:
        try:
            beer_result = beer[brewery_id]
            return beer_result, brewery_names[brewery_id.split("-")[0]]
        except:
            return None


def find_beers_from_brewery(brewery_id):
    pattern = re.compile('^' + brewery_id + '-.*')
    beers = [value for key, value in beer.items() if pattern.match(key)]
    return beers


class BeerInfo(object):

    def __init__(self, beer_id, brewery_name, item_json):
        self._id = beer_id
        self.parent_style = item_json[1][1]
        self.base_style = item_json[1][0]
        self.name = item_json[0]
        self.abv = item_json[2]
        self.brewer = brewery_name
        self.num_reviews = item_json[3]
        self.drinks_like = get_drinks_like(self._id)
        self.link ="/brewery/" + beer_id.split('-')[0] + '/' + beer_id.split('-')[1]

class Brewery(object):

    def __init__(self, breweryid):
        self.id = breweryid
        self.brews = []

    def add_brew(self, brew):
        self.brews.append(brew)


if __name__ == '__main__':
    app.config.update(TEMPLATES_AUTO_RELOAD=True)
    app.run(host='0.0.0.0')