def yelp_rec_callback(data):
process_businesses(data["businesses"])
self.onpage += 1
print "Page?", self.onpage, self.total_pages
if self.onpage >= self.total_pages:
after_yelp()
return
print "Searching Yelp..."
yelp_search(yelp_rec_callback, latitude=lat, longitude=lon,
offset=self.onpage * 20, redis=self.redis)
def get(self):
latitude = self.get_argument("lat")
longitude = self.get_argument("lon")
user_tastes = set()
def collect_yelp(data):
business_categories = set()
for business in data["businesses"]:
for foo, c in business["categories"]:
if c not in TASTES:
continue
business_categories.add(c)
business_categories -= user_tastes
while len(business_categories) < 5:
business_categories.add(random.choice(TASTES))
to_ask_range = math.ceil(len(user_tastes) / 5)
to_ask_ranges = {0: 5, 1: 4, 2: 4, 3: 2}
to_ask = 0
if to_ask_range in to_ask_ranges:
to_ask = to_ask_ranges[to_ask_range]
else:
to_ask = 2
self._format_output({"result": "okay",
"tastes": list(business_categories),
"to_ask": to_ask})
self.finish()
# Post the data to the cache.
return
self.redis.set("cache::yelp::%s,%s" % (latitude, longitude),
json.dumps(data))
user_tastes = self.redis.sunion("tastes::like::%s" % self.email,
"tastes::dislike::%s" % self.email)
user_tastes = frozenset(user_tastes)
yelp_search(collect_yelp, latitude=latitude, longitude=longitude,
redis=self.redis)
def get(self):
lat = self.get_argument("lat")
lon = self.get_argument("lon")
user_tastes = self.redis.smembers("tastes::like::%s" % self.email)
user_dislikes = self.redis.smembers("tastes::dislike::%s" % self.email)
user_history = self.redis.lrange("places::history::%s" % self.email,
0, 5)
place_reasons_key = "places::reasons::%s::%%s" % self.email
place_scores = "places::score::%s" % str(uuid.uuid4())
self.redis.delete(place_scores)
def process_businesses(businesses):
for business in businesses:
key = business["id"]
reason_key = place_reasons_key % key
self.redis.delete(reason_key)
score = 0
if business["distance"] < 500:
self.redis.sadd(reason_key, "distance")
score += 1
else:
distance = business["distance"]
if distance > 1000:
distance -= 1000
score -= math.floor(distance / 500)
place_rating = parse_rating(business["rating_img_url"])
if place_rating > 4:
self.redis.sadd(reason_key, "great_rating")
score += 2
elif place_rating > 3:
self.redis.sadd(reason_key, "good_rating")
score += 1
for friendly_cat, category in business["categories"]:
if category in user_dislikes:
score -= 4
elif category in user_tastes:
score += 3
self.redis.sadd(reason_key, "like:%s" % category)
if key in user_history:
score -= 3
else:
self.redis.sadd(reason_key, "notrecent")
# Add the data to redis for this session
print place_scores, score, key
self.redis.zadd(place_scores, key, score)
def yelp_callback(data):
self.total_results = data["total"]
self.total_pages = math.ceil(self.total_results / 20)
self.total_pages = min(self.total_pages, settings.YELP_PAGES)
yelp_rec_callback(data)
def yelp_rec_callback(data):
process_businesses(data["businesses"])
self.onpage += 1
print "Page?", self.onpage, self.total_pages
if self.onpage >= self.total_pages:
after_yelp()
return
print "Searching Yelp..."
yelp_search(yelp_rec_callback, latitude=lat, longitude=lon,
offset=self.onpage * 20, redis=self.redis)
def after_yelp():
print "After yelp"
pick = self.redis.zrevrange(place_scores, 0, 1)[0]
pick_reasons = self.redis.smembers(place_reasons_key % pick)
self.redis.delete(place_reasons_key % pick)
def pick_output(data):
print "Pick output"
print pick_reasons
self.write({"result": "okay",
"business": data,
"reasons": list(pick_reasons),
"stars": parse_rating(data["rating_img_url"])})
self.finish()
business_data(pick_output, pick, redis=self.redis)
self.redis.lpush("places::history::%s" % self.email, pick)
print "Searching Yelp initially..."
yelp_search(yelp_callback, latitude=lat, longitude=lon,
categories=user_tastes, redis=self.redis)
def _render_choices(self, group_id, lat, lon):
members = self.redis.smembers("group::%s" % group_id)
user_tastes = self.redis.sunion(map(lambda i: "tastes::like::%s" % i, members))
user_dislikes = self.redis.sunion(map(lambda i: "tastes::dislike::%s" % i, members))
print "Tastes: ", user_tastes
print "Dislikes: ", user_dislikes
histories = set()
for member in members:
for h in self.redis.lrange("places::history::%s" % member, 0, 3):
histories.add(h)
place_reasons_key = "places::reasons::group_%s::%%s" % group_id
place_scores = "places::group_score::%s" % group_id
self.redis.delete(place_scores)
def process_businesses(businesses):
for business in businesses:
key = business["id"]
reason_key = place_reasons_key % key
self.redis.delete(reason_key)
score = 0
if business["distance"] < 500:
self.redis.sadd(reason_key, "distance")
score += 1
else:
distance = business["distance"]
if distance > 1000:
distance -= 1000
score -= math.floor(distance / 500)
place_rating = parse_rating(business["rating_img_url"])
if place_rating > 4:
self.redis.sadd(reason_key, "great_rating")
score += 2
elif place_rating > 3:
self.redis.sadd(reason_key, "good_rating")
score += 1
for friendly_cat, category in business["categories"]:
if category in user_dislikes:
score -= 3
else:
self.redis.sadd(reason_key, "notrecent")
# Add the data to redis for this session
print place_scores, score, key
self.redis.zadd(place_scores, key, score)
def yelp_callback(data):
self.total_results = data["total"]
self.total_pages = math.ceil(self.total_results / 20)
self.total_pages = min(self.total_pages, settings.YELP_PAGES)
yelp_rec_callback(data)
def yelp_rec_callback(data):
process_businesses(data["businesses"])
self.onpage += 1
print "Page?", self.onpage, self.total_pages
if self.onpage >= self.total_pages:
after_yelp()
return
print "Searching Yelp..."
yelp_search(yelp_rec_callback, latitude=lat, longitude=lon,
offset=self.onpage * 20, redis=self.redis)
def after_yelp():
print "After yelp"
def get_tiny_business(choice):
id_, score = choice
data = json.loads(self.redis.get("cache::business::%s" % id_))
return (data["name"], score, id_)
picks = self.redis.zrevrange(place_scores, 0, 3, withscores=True)
picks = map(get_tiny_business, picks)
#pick_reasons = self.redis.smembers(place_reasons_key % pick)
#self.redis.delete(place_reasons_key % pick)
latitude = self.redis.hget("group_props::%s" % group_id, "lat")
longitude = self.redis.hget("group_props::%s" % group_id, "lon")
self.write({"result": "okay",
"registered": "yes",
"members": list(members),
"choices": picks,
"latitude": latitude,
"longitude": longitude})
self.finish()
print "Searching Yelp initially... (g)"
yelp_search(yelp_callback, latitude=lat, longitude=lon,
categories=user_tastes, redis=self.redis)
