from flask import Flask, render_template, request, redirect

from numpy import dot, sqrt,load,array,argsort,sum,count_nonzero,any, log

#from pandas import read_csv

from requests import get

from time import sleep

from xmltodict import parse

from random import sample, choice

from dill import load as lode

import networkx as nx

from json import dumps

from networkx.readwrite import json_graph

from sklearn.preprocessing import StandardScaler

#from pandas import read_csv

#from bs4 import UnicodeDammit

app = Flask(__name__)

app.vars={}

class catMechTransformer():

return [self.flatten(i) for i in X]

def category_and_mechanic_table(games):

return categories, mechanics, outData

def tanimotoSimilarity(user1, user2):

return z

def GameTree(row):

return G, [i[0] for i in out[u'A Hypothetical Game']], [d[i[0]] for i in out[u'A Hypothetical Game']]

# loading in resources. I know pickles and .npy files are unsafe, but for testing the performance gains were worth it. gameList is a list of games, their BoardGamegGek id number, and name. a Matrix is a precomputed similarity matrix of user recommendations such that we can dot our vector of game ratings into it to get a user-user similarity. aMatrixMasked is set up to allow us to quickly sum the similarities. It's the previous matrix with the nonzero entries set to one. It will allow us to quickly sum the similarities in user-user. This user-user uses cosine similarity.

#app.gamesNames=[[i[0],i[1]] for i in read_csv("gameList.csv", quotechar='"', skipinitialspace=True).as_matrix()]

#app.recs = load('aMatrixHalfFloat.npy')

#app.recsMasked = load('aMatrixMaskedHalfFloat.npy')

# itemitem is a similarity between the columns of a using Tanimoto similarity

#app.itemRecs = load('itemitemHalfFloat.npy')

# itemitem is a similarity between the rows of a matrix of game information using Tanimoto similarity. it's slightly weighted towards game ownership and comments on the game.

app.gameRecs = load('gamegameHalfFloat.npy')

app.gameData = load('gameData.p')

app.gamesNames = [[i[0], i[1]] for i in app.gameData]

app.gameScores = [i[13] for i in app.gameData]

app.gameFactors = load('gameFactors.npy')

app.cats, app.mechs, app.gameNorm = category_and_mechanic_table(app.gameData)

app.transformer = StandardScaler().fit(app.gameNorm)

cNorm = []

outData = app.transformer.transform(app.gameNorm)

for i in app.gameNorm:

j = 1./sqrt(float(dot(i, i)))

cNorm.append(list(map(lambda x: j * x, i)))

app.gameNorm = cNorm

del cNorm

app.model = lode(open('gamescoremodel','rb'))

@app.route('/')

def main():

return render_template('landing.html')

@app.route('/about')

def about():

return render_template('about.html')

@app.route('/user',methods=['GET','POST'])

def user():

return redirect('/main_username')

@app.route('/game', methods = ['GET','POST'])

def game():

return render_template('error.html', message = 'Please enter valid input.')

#the string that appears if a username is invalid

noUser = u'<?xml version="1.0" encoding="utf-8" standalone="yes" ?>\n<errors>\n\t<error>\n\t\t<message>Invalid username specified</message>\n\t</error>\n</errors>'

@app.route('/main_username', methods = ['GET','POST'])

def main_username():

return redirect('/main_entered')

@app.route('/main_entered', methods = ['GET','POST'])

def main_entered():

return render_template('results2.html', sim=[i[0] for i in ratings], games=[i[2].replace('\,',',') for i in ratings], nums=[int(i[1]) for i in ratings], inprops=inProps, outprops = outProps, game_text = [i[3].replace('\,',',').replace('\n\n','</p><p>') for i in ratings])#inProps,outprops=outProps)

#the gameData table has a bunch of comments about each game, this function pulls out the most common.

def properties(keys):

return [mostCommon(inpropsCat), mostCommon(inpropsMech)],[mostCommon(outpropsCat), mostCommon(outpropsMech)]

def copacetic(ratings):

return a[:10], newnewkeys[:10]

#calculating the different sorts of recommendations

# def ownership_recs(user, recs):

# totals = dot(user,recs)

# simssum = dot(map(lambda x: 1 if x > 0 else 0,user),recs)

# rankings = [app.gameData[i][13] + totals[i]/simssum[i] for i in range(len(totals))]

# del totals, simssum

# #print 'item rankings', rankings[:20]

# return rankings

#if the rows are normalized cosine similarity reduces to a dot product between the matrix we care about and our vector of ratings. The normalization of the vector will eventually cancel out so we don't have to worry about it

def getRecs(user):

return rankings

def toGameAndRating(xml):

app.vars['ratings'] = ratings

errorMessage=u'<html>\n <head>\n <title>Error 503 Service Unavailable</title>\n </head>\n <body>\n <h1>503 Service Unavailable</h1>\n Our apologies for the temporary inconvenience. The requested URL generated 503 "Service Unavailable" error due to overloading or maintenance of the server.\n </body>\n</html>\n'

def makeRequest(name):

sleep(0.15)

def returnOwnership(item):

ownership = 1 if (item[u'status'][u'@own'] == '1') or (item[u'status'][u'@prevowned'] == '1') or (item[u'status'][u'@preordered'] == '1') else 0

#wanting = 0.5 if (item[u'status'][u'@want'] == '1') or (item[u'status'][u'@wanttobuy'] == '1') or (item[u'status'][u'@wishlist'] == '1') else 0

return ownership #max([ownership,wanting])

@app.errorhandler(404)

def error(e):

return render_template('error.html',message='Something\'s wrong.')

@app.errorhandler(500)

def error(e):

return render_template('error.html',message='Something\'s wrong.')

if __name__ == '__main__':

app.debug = False

# app.run(port=33507)

app.run(port=33508)

# app.run(host='0.0.0.0')