def restaurant(request):
if request.method == 'POST':
form = RestaurantSearch(data=request.POST)
if form.is_valid():
#Capture user input, assign it to variable 'name'
name = form.cleaned_data['name']
#Nutritionix API request
nix = Nutritionix(app_id="a70d76f6", api_key="e0d08a959dacfd68dd69b5473f2fc41c")
cal1 = nix.search(offset="0", limit="50").nxql(
queries={
"brand_name":name,
},
fields=["item_name", "brand_name", "nf_calories", "nf_total_fat", "nf_protein", "nf_total_carbohydrate",
"nf_sodium"],
).json()
response1 = json.dumps(cal1)
a = json.loads(response1)
b = (a.get("hits"))
r = []
for c in b:
kitten = (c.get("fields").get("brand_name"))
if kitten not in r:
r.append(kitten)
context = {'form':form,'name':name,'r':r}
return render(request, 'macro/restaurant.html', context)
else:
form = RestaurantSearch()
context = {'form':form}
return render(request, 'macro/restaurant.html', context)
def nutritionix_wrapper(label):
"""
This function will take a label and give out the weight to calories ratio
input: label (string)
output: weight / calories (double)
"""
nutritionix_id = nutritionix_ID(label)
nix = Nutritionix(app_id="8dfdbdb1", api_key="66ad2fcd0f25722ca73662505e9fd492")
nutritionix_info = nix.item(id=nutritionix_id).json()
weight_key = 'nf_serving_weight_grams'
calories_key = 'nf_calories'
weight = nutritionix_info[weight_key]
calories = nutritionix_info[calories_key]
if weight is not None and calories is not None:
print('ME GOOD')
ratio = calories / weight
return ratio
print('ME BAD')
return 0
def lambda_handler(event, context):
search = ""
if event != None and 'pathParameters' in event:
search = event['pathParameters']['search']
if len(search) > 0:
nix = Nutritionix(app_id=os.environ["app_id"],
api_key=os.environ["api_key"])
nix_results = nix.search().nxql(fields=[
"item_id", "item_name", "brand_name", "nf_total_carbohydrate"
],
query=search).json()
else:
nix_results = {'hits': []}
results = {'hits': []}
count = 0
for hit in nix_results['hits']:
if hit['fields']['nf_total_carbohydrate'] is not None:
results['hits'].append({
'id':
count,
'value':
'%s, %s, %sg' %
(hit['fields']['item_name'], hit['fields']['brand_name'],
hit['fields']['nf_total_carbohydrate'])
})
count += 1
pass
return respond(None, results['hits'])
def nutritionix_ID(label):
"""
This function will give the first product ID for a specific label
input: label (string)
output: ID (string)
"""
nix = Nutritionix(app_id="8dfdbdb1", api_key="66ad2fcd0f25722ca73662505e9fd492")
return nix.search(label, results="0:1").json()['hits'][0]['fields']['item_id']
def findMeal(request):
""" Finds meal based on POST request from client.
Arguments:
request -- should contain restaurant name and
macros in a matrix (protein, fat, carbs)
"""
if request.method == "GET":
restaurant_name = request.GET['restaurant']
# for testing purposes
#Restaurant.objects.get(name=restaurant_name).delete()
try:
# Query restaurant items
restaurant = Restaurant.objects.get(name=restaurant_name)
except Exception as e: # if not found, query Nutritionix database
# query database
nix = Nutritionix()
nixResults = nix.search().nxql(queries={
"brand_name": "%s" % restaurant_name
},
filters={
"item_type": 1
},
fields=[
"item_name", "nf_total_fat",
"nf_total_carbohydrate",
"nf_protein"
]).json()
# Invalid restaurant name returns no results
if (nixResults["total"] == 0):
return HttpResponse("Invalid request")
# Store restaurant items into DB
items = []
for item in nixResults["hits"]:
items.append(item["fields"])
Restaurant.objects.create(name=restaurant_name, items=items)
# Query restaurant items
restaurant = Restaurant.objects.get(name=restaurant_name)
clientMacros = request.GET['macros']
items = restaurant.items
# find closest meal to fit macros
# for meal in restaurant.items:
# item = meal
return HttpResponse(restaurant.items)
else:
return HttpResponse("Invalid request")
def result():
print(request.form['out'])
chosenLabel = request.form['out']
nix = Nutritionix(app_id="b3151f58",
api_key="f9c4b99b77d236006962c81e4ddbffee")
apple = nix.search(chosenLabel)
results = apple.json()
resultsItem = nix.item(id=results['hits'][0]['fields']['item_id']).json()
return render_template('description.html',
sum=wikipedia.summary(chosenLabel, sentences=3),
calories=str(resultsItem['nf_calories']),
serving=str(resultsItem['nf_serving_weight_grams']))
def __init__(self, nutritionix_id = "46e19a0a", \
nutritionix_key = "b05d85f8570c41a40f5bc4cca2c5d57f"):
self.nix = Nutritionix(app_id=nutritionix_id, api_key=nutritionix_key)
self.food_model = \
{u'nf_ingredient_statement': u'',
u'nf_serving_weight_grams': 0,
u'allergen_contains_soybeans': None,
u'brand_name': u"",
u'nf_calories_from_fat': 0,
u'nf_calcium_dv': 0,
u'brand_id': u'',
u'allergen_contains_eggs': None,
u'nf_iron_dv': 0,
u'nf_cholesterol': 0,
u'item_description': u'',
u'usda_fields': None,
u'nf_monounsaturated_fat': None,
u'nf_dietary_fiber': 0,
u'item_name': u'',
u'allergen_contains_tree_nuts': None,
u'allergen_contains_shellfish': None,
u'nf_vitamin_c_dv': 0,
u'nf_polyunsaturated_fat': None,
u'allergen_contains_peanuts': None,
u'nf_sugars': 0,
u'nf_servings_per_container': None,
u'nf_total_fat': 0,
u'nf_total_carbohydrate': 0,
u'leg_loc_id': 0,
u'nf_saturated_fat': 0,
u'allergen_contains_wheat': None,
u'old_api_id': None,
u'updated_at': u'',
u'allergen_contains_gluten': None,
u'nf_protein': 0,
u'item_id': u'',
u'nf_calories': 0,
u'nf_water_grams': None,
u'allergen_contains_fish': None,
u'nf_trans_fatty_acid': 0,
u'nf_serving_size_qty': 0,
u'allergen_contains_milk': None,
u'nf_vitamin_a_dv': 0,
u'nf_serving_size_unit': u'',
u'nf_refuse_pct': None,
u'nf_sodium': 0,
u'food_group': u'',
u'food_subgroup': u'',
u'restaurant_id': u'',
u'restaurant_name': u''}
def nutritionix_calories(nutritionix_id):
"""
This function will take an ID and return calories | Useful for the total count of calories per user
input: id (string)
output: calories
"""
nix = Nutritionix(app_id="8dfdbdb1", api_key="66ad2fcd0f25722ca73662505e9fd492")
calories_key = 'nf_calories'
nutritionix_info = nix.item(id=nutritionix_id).json()
calories = nutritionix_info[calories_key]
if calories is not None:
return calories
else:
return None
def FatFinder(string):
num = 1
###From https://github.com/leetrout/python-nutritionix###
from nutritionix import Nutritionix
api_key = "5fc43e41551148e7105f4c0b6e8cba31"
app_id = "cd1f176e"
nix = Nutritionix(app_id, api_key)
stringsearch = nix.search(string, results=("0:"+str(num))).json()
### My Code ###
item_id = stringsearch["hits"][0]["fields"]["item_id"]
itemidsearch = nix.item(id=str(item_id)).json()
itemfat = itemidsearch['nf_saturated_fat']
if itemfat is None:
OUTPUT = "Please enter a food that contains Fat. "
return OUTPUT
else:
return itemfat
def get_nutrient(food):
"""Hepler function to get raw data for a food from API.
Arguments:
food {string} -- food to be found
Returns:
detail {dictionary} -- raw data is store in the dictionary
"""
nix = Nutritionix(app_id=APP_ID, api_key="")
a = nix.search(food, results="0:1").json()
detail = {}
if 'hits' in a:
hits = a['hits']
try:
item_id = hits[0]['_id']
detail = nix.item(id=item_id).json()
except IndexError:
pass
detail["key_ingredient"] = food
print(detail["key_ingredient"])
return detail
def results(request):
if request.method == 'GET':
sku = request.GET.get('sku')
nix = Nutritionix(app_id="a70d76f6", api_key="e0d08a959dacfd68dd69b5473f2fc41c")
cal1 = nix.search(offset="0", limit="50").nxql(
queries={
"brand_name": sku,
},
fields=["item_name", "brand_name", "nf_calories", "nf_total_fat", "nf_protein", "nf_total_carbohydrate",
"nf_sodium"],
).json()
response1 = json.dumps(cal1)
a = json.loads(response1)
b = (a.get("hits"))
r = []
blue = []
aye = []
for c in b:
kitten = (c.get("fields").get("brand_name"))
kitten1 = (c.get("fields").get("item_name"))
kitten2 = (c.get("fields").get("nf_calories"))
if kitten == sku:
r.append(kitten)
blue.append(kitten1)
aye.append(kitten2)
h = len(blue)
context = {'sku':sku,'r':r,'blue':blue,'aye':aye,'h':h}
return render(request, 'macro/results.html',context)
else:
return render(request, 'macro/results.html')
def download(examples_to_download, offset, only_calories):
save_file = create_new_file(examples_to_download, offset, only_calories)
nix = Nutritionix(app_id=private_consts.NUTRITIONIX["app_id"],
api_key=private_consts.NUTRITIONIX["api_key"])
items = []
num_calls = examples_to_download / ITEMS_PER_API_CALL
for i in range(num_calls):
print "Downloading items {0} through {1}".format(
i * ITEMS_PER_API_CALL + offset,
(i + 1) * ITEMS_PER_API_CALL + offset)
results = nix.search().nxql(filters=create_filter(only_calories),
offset=i * ITEMS_PER_API_CALL + offset,
limit=ITEMS_PER_API_CALL).json()
items += [hit["_source"] for hit in results["hits"]]
# Save data
print "Saving " + str(len(items)) + " items"
pickle.dump(items, open(save_file, "wb"))
return
def download(examples_to_download, offset, only_calories):
save_file = create_new_file(examples_to_download, offset, only_calories)
nix = Nutritionix(app_id=private_consts.NUTRITIONIX["app_id"],
api_key=private_consts.NUTRITIONIX["api_key"])
items = []
num_calls = examples_to_download/ITEMS_PER_API_CALL
for i in range(num_calls):
print "Downloading items {0} through {1}".format(i*ITEMS_PER_API_CALL + offset, (i+1)*ITEMS_PER_API_CALL + offset)
results = nix.search().nxql(
filters = create_filter(only_calories),
offset = i*ITEMS_PER_API_CALL + offset,
limit = ITEMS_PER_API_CALL
).json()
items += [hit["_source"] for hit in results["hits"]]
# Save data
print "Saving " + str(len(items)) + " items"
pickle.dump( items, open( save_file, "wb" ) )
return
from nutritionix import Nutritionix
from logos import getlogo
# Application ID:
appid = 'ffb27ccd'
# API Key:
apikey = '516561556bb62da642a4824b86084d02'
nix = Nutritionix(app_id=appid, api_key=apikey)
def search_calls(searchTerm):
itemID=None
pizza2 = nix.search(searchTerm) # , results="0:1")
json = pizza2.json()
for dics in json['hits']:
if searchTerm in dics['fields']['item_name']:
itemID = dics['fields']['item_id']
break
if not bool(itemID):
itemID = str(json['hits'][0]['fields']['item_id'])
itemJSON = nix.item(id=itemID).json()
calories = itemJSON['nf_calories']
grams = itemJSON['nf_serving_weight_grams']
serving_quant = itemJSON['nf_serving_size_qty']
serving_units = itemJSON['nf_serving_size_unit']
serving = str(serving_quant) + " " + serving_units
calories_per_serving = str(calories) + " calories per " + serving
return searchTerm, calories_per_serving, calories, serving_units
from nutritionix import Nutritionix
nix = Nutritionix(app_id="7f770e5d", api_key="dae4065c600b6b161789a27471167ccd") #make these env variables later
def canAdd(item, oneMealPlan, max_total_fat, max_cholesterol, max_saturated_fat, max_sodium, max_sugar):
#print "Saturated fat-----------"
#print oneMealPlan['saturated_fat']
#print item['saturated_fat']
#print "----------------------"
if item['saturated_fat'] is None:
item['saturated_fat'] = 0
if item['sugar'] is None:
item['sugar'] = 0
if item['total_fat'] is None:
item['total_fat']=0
return ((oneMealPlan['total_fat'] + item['total_fat'] <= max_total_fat) and
(oneMealPlan['saturated_fat'] + item['saturated_fat'] <= max_saturated_fat) and
(oneMealPlan['cholesterol'] + item['cholesterol'] <= max_cholesterol) and
(oneMealPlan['sodium'] + item['sodium'] <= max_sodium) and
(oneMealPlan['sugar'] + item['sugar'] <= max_sugar))
# restriction should be the array of food restrictions, each element would be the string name
# calories_max is from the profile
# limit number should be 10 for getting 10 meal suggestion
# if getting 10 more, have offset_value = 10, otherwise 0
def getMealPlan(restrictions, calories_min, limit_number, offset_value, food_type,
from nutritionix import Nutritionix
nix = Nutritionix(app_id="0acff812", api_key="fe3234b8d467860ae368067d62ae5600")
result = nix.item(id="513fc9e73fe3ffd40300109f").json()
num = result['nf_protein']
den = result['nf_serving_weight_grams']
proRatio = float(num)/float(den)
print proRatio
### Iteration for 100 most protein filled
ff = nix.search().nxql(
filters={
"nf_protein": {
"gte": 120
}
},
fields=["item_name", "item_id"]
).json()
print ff
from nutritionix import Nutritionix
import sys
def search(s):
val = nix.search(s).json()[u'hits'][0]
item_id = val[u'fields'][u'item_id']
name = val[u'fields'][u'item_name']
carbs = nix.item(id=item_id).json()[u'nf_total_carbohydrate']
print name, carbs, 'carbs'
nix = Nutritionix(app_id="89b2a057",
api_key="8bdfcf6398c7c4d6ab6407b92826264a")
query = raw_input()
print search(query)
sys.stdout.flush()
continue
else:
break
print("----------------------------------------------------------------")
print("Today is ", datetime.datetime.now().strftime("%Y-%B-%d"))
print("Today's Food For You: ")
if gender == "male":
need_calories = (10 * weight * 0.4536 + 6.25 * height * 30.48 -
5 * age + 5) * 1.2
elif gender == "female":
need_calories = (10 * weight * 0.4536 + 6.25 * height * 30.48 -
5 * age - 161) * 1.2
nix = Nutritionix(app_id="your_app_id", api_key="your_api_key")
obj = nix.search().nxql(
filters={
"nf_calories": {
#"lte": 500
"from": 200,
"to": 500
}
},
fields=["item_name", "nf_calories"]).json()
results = []
for food in obj['hits']:
result = {
"item_name": food['fields']['item_name'],
def extract_nutrition_data(query):
nix = Nutritionix(app_id="ac86d1b1", api_key="290ca52d8ffea5cfa546000bb592c349")
query = nix.search(query).json()
return query
#Some errors exist
from flask import Flask
from flask_ask import Ask, statement, question, session
import json, urllib
import time
import requests
from nutritionix import Nutritionix
nix = Nutritionix(app_id="app_id", api_key="app")
app = Flask(__name__)
ask = Ask(app, "/food_name")
def get_info(food):
url = "https://api.nutritionix.com/v1_1/search/food?results=0:10&fields=item_name,brand_name&appId=app_id&appKey=app_key"
f = urllib.urlopen(url)
values = json.load(f)
f.close()
results = []
for i_n in values['hits']['i_n']['fields']:
results.append[{
values['hits']['i_n']['fields']['item_name'],
values['hits']['i_n']['fields']['brand_name']
}]
results = '... '.join([i for i in results])
return results
results = get_info("dosa")
print(results)
# -*- coding: utf-8 -*-
"""
Created on Tue Nov 6 16:52:32 2018
@author: Jonathon
"""
from nutritionix import Nutritionix
import mysql.connector
from mysql.connector import errorcode
#Set up for script run
ifile = open('food_list.txt', "rt")
nix = Nutritionix(app_id="27b883d2",
api_key="6765efa618f90e2eaca84fda9f90d69f")
try:
connection = mysql.connector.connect(
user='******',
password='******',
host='advsoft.codryjh8aaby.us-west-2.rds.amazonaws.com',
database='mydb')
except mysql.connector.Error as err:
if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
print("Something is wrong with your user name or password")
elif err.errno == errorcode.ER_BAD_DB_ERROR:
print("Database does not exist")
else:
print(err)
cursor = connection.cursor()
with open('lipton.jpg', 'rb') as f:
response = api.image_request(f, 'lipton.jpg', {
'image_request[locale]': 'en-US',
})
status = api.image_response(response['token'])
if status['status'] != cloudsight.STATUS_NOT_COMPLETED:
# Done!
pass
status = api.wait(response['token'], timeout=30)
from nutritionix import Nutritionix
nix = Nutritionix(app_id="76986486", api_key="28882f3d105c4c9e3222a05eeafd049a")
result = nix.search('pizza').json()
from flask import Flask, request, jsonify
#sudo pip install flask-cors
from flask_cors import CORS
from nutritionix import Nutritionix
nix = Nutritionix(app_id="67a461a2",
api_key="e2e3a5f32358c6197ad841f6a0bbbb0d")
app = Flask(__name__)
CORS(app)
#pizza = nix.search("pizza")
#print nix.search('big mac', results="0:1").json()
print nix.item(id="58bedf1bde25a28564cebeb9").json()
@app.route('/', methods=['GET'])
def home_page():
return "Hello, World!"
@app.route('/hand_checker', methods=['POST'])
def hand_checker():
# print request.form
hand = request.form.getlist('hand[]')
print hand
#hand = ['1h 2h 1s 9d 13d']
return jsonify({'message': 'You have %s and %s!' % (hand[0], hand[1])})
if __name__ == '__main__':
class FoodNutrition(object):
def __init__(self, nutritionix_id = "46e19a0a", \
nutritionix_key = "b05d85f8570c41a40f5bc4cca2c5d57f"):
self.nix = Nutritionix(app_id=nutritionix_id, api_key=nutritionix_key)
self.food_model = \
{u'nf_ingredient_statement': u'',
u'nf_serving_weight_grams': 0,
u'allergen_contains_soybeans': None,
u'brand_name': u"",
u'nf_calories_from_fat': 0,
u'nf_calcium_dv': 0,
u'brand_id': u'',
u'allergen_contains_eggs': None,
u'nf_iron_dv': 0,
u'nf_cholesterol': 0,
u'item_description': u'',
u'usda_fields': None,
u'nf_monounsaturated_fat': None,
u'nf_dietary_fiber': 0,
u'item_name': u'',
u'allergen_contains_tree_nuts': None,
u'allergen_contains_shellfish': None,
u'nf_vitamin_c_dv': 0,
u'nf_polyunsaturated_fat': None,
u'allergen_contains_peanuts': None,
u'nf_sugars': 0,
u'nf_servings_per_container': None,
u'nf_total_fat': 0,
u'nf_total_carbohydrate': 0,
u'leg_loc_id': 0,
u'nf_saturated_fat': 0,
u'allergen_contains_wheat': None,
u'old_api_id': None,
u'updated_at': u'',
u'allergen_contains_gluten': None,
u'nf_protein': 0,
u'item_id': u'',
u'nf_calories': 0,
u'nf_water_grams': None,
u'allergen_contains_fish': None,
u'nf_trans_fatty_acid': 0,
u'nf_serving_size_qty': 0,
u'allergen_contains_milk': None,
u'nf_vitamin_a_dv': 0,
u'nf_serving_size_unit': u'',
u'nf_refuse_pct': None,
u'nf_sodium': 0,
u'food_group': u'',
u'food_subgroup': u'',
u'restaurant_id': u'',
u'restaurant_name': u''}
def get_food_healthy_score(self, food_id):
# traverse scored nutrients
score = 0
score_nutrients = FoodScoreNutrient.query.all()
# get food tuple
food = Food.query.filter_by(food_id=food_id).first()
food_energy = food.energy
for score_nutrient in score_nutrients:
# get scored nutrient info
score_nutrient_name = score_nutrient.score_nutrient_name
nutrient_dv = float(score_nutrient.nutrient_dv)
if score_nutrient.recommend:
recom_flag = 1
else:
recom_flag = -1
# get corresponding food nutrient
try:
food_nutrient = float(eval('food.' + score_nutrient_name))
except:
food_nutrient = 0
# calculate
score += recom_flag * (food_nutrient / nutrient_dv) / food_energy
# update food healthy score
food.healthy_score = score
db.session.add(food)
db.session.commit()
return score
def search_food_name(self,
food_name,
result_num=10,
prior_search="hpb_focos"):
if prior_search == "hpb_focos":
name_results = self.hpb_focos_search_food_name(
food_name, result_num)
search_num = len(name_results)
if search_num < result_num:
name_results_2 = self.nutritionix_search_food_name(food_name, \
result_num - search_num)
search_num += len(name_results_2)
name_results.update(name_results_2)
if search_num < result_num:
print "Only get " + str(search_num) + " results!"
elif prior_search == "nutritionix":
name_results = self.nutritionix_search_food_name(
food_name, result_num)
search_num = len(name_results)
if search_num < result_num:
name_results_2 = self.hpb_focos_search_food_name(food_name, \
result_num - search_num)
search_num += len(name_results_2)
name_results.update(name_results_2)
if search_num < result_num:
print "Only get " + str(search_num) + " results!"
else:
raise Exception("prior_search must be hpb_focos or nutritionix!")
return name_results
def search_food_id(self, food_id):
if food_id[0:8] == 'hpbfocos':
food_id = food_id[8:]
food = self.hpb_focos_search_food_id(food_id)
else:
food = self.nutritionix_search_food_id(food_id)
return food
def nutritionix_search_food_name(self, food_name, result_num=5):
# result_num should <= 50
if result_num <= 50:
try:
search_result = self.nix.search(food_name, results = "0:" + \
str(result_num)).json()
except: # > total results
search_num = self.nix.search(food_name).json()['total_hits']
search_result = nix.search(food_name, results = "0:" + \
str(search_num)).json()
else:
raise Exception("Result num must <= 50!")
results = search_result['hits']
name_results = {}
for result in results:
name_results[result[u'fields'][u'item_name']] = result[u'_id']
return name_results
def nutritionix_search_food_id(self, food_id):
try:
food_entry = self.nix.item(id=food_id).json()
except:
raise Exception("Invalid Food ID")
return food_entry
def hpb_focos_search_food_name(self, food_name, result_num=5):
results = db.session.query(HpbFocosFood).filter(HpbFocosFood.\
food_name.like('%%' + food_name + '%%')).all()
search_num = len(results)
if result_num <= search_num:
results = results[0:result_num]
else:
print "Only get " + str(search_num) + " search results!"
name_results = {}
for result in results:
name_results[result.food_name] = u'hpbfocos' + str(result.food_id)
return name_results
def hpb_focos_search_food_id(self, food_id):
hpb_food = HpbFocosFood.query.filter_by(food_id=food_id).first()
food = {}
food[u'nf_serving_weight_grams'] = hpb_food.serving_gram
# food[u'nf_calcium_dv'] = 0,
# u'nf_iron_dv': 0,
food[u'nf_cholesterol'] = hpb_food.cholesterol
food[u'nf_dietary_fiber'] = hpb_food.fiber
food[u'item_name'] = hpb_food.food_name
# u'nf_vitamin_c_dv': 0,
food[u'nf_total_fat'] = hpb_food.fat
food[u'nf_total_carbohydrate'] = hpb_food.carb
food[u'nf_saturated_fat'] = hpb_food.sat_fat
food[u'nf_protein'] = hpb_food.protein
food[u'item_id'] = u'hpbfocos' + str(hpb_food.food_id)
food[u'nf_calories'] = hpb_food.energy
#u'nf_vitamin_a_dv': 0,
food[u'nf_serving_size_unit'] = hpb_food.serving_unit
food[u'nf_sodium'] = hpb_food.sodium
food[u'food_group'] = hpb_food.food_group
food[u'food_subgroup'] = hpb_food.food_subgroup
return food
from flask import Flask, render_template, request
from nutritionix import Nutritionix
import pandas as pd
import numpy as np
nix = Nutritionix(app_id='6fb672d6',
api_key='7f302d3d7ef120d41979e92a6831e472')
app = Flask(__name__)
@app.route('/')
@app.route('/index')
def index():
return render_template('index.html',
products=total_products(),
all_list=all_items_list(),
avgs=average_calories(),
index=index_ingredients(),
indexdf=ingredientsdf())
# REQUIREMENT 1: return total number of Juicy Juice products in JSON format.
def total_products():
juice = nix.search().nxql(filters={
'brand_id': '51db37d0176fe9790a899db2'
}).json()
total = (juice['total'])
return total
from nutritionix import Nutritionix
import json
nix = Nutritionix(app_id="XXXXXXXX", api_key="XXXXXXXXXXXXXXXXXXXXXXXXXXX")
mcd_search = nix.search().nxql(queries={"brand_name": "mcdonald"}).json()
mcd_hits = mcd_search['total']
dict_mcd = []
for i in range(round(mcd_hits / 50) + 1):
data = nix.search().nxql(
queries={
"brand_name": "mcdonald"
},
fields=[
"brand_name", "brand_id", "item_name", "item_id", "updated_at",
"nf_calories", "nf_total_fat", "nf_saturated_fat",
"nf_cholesterol", "nf_sodium", "nf_total_carbohydrate",
"nf_dietary_fiber", "nf_sugars", "nf_protein",
"nf_servings_per_container", "nf_serving_size_qty",
"nf_serving_size_unit", "nf_serving_weight_grams"
],
offset=i * 50,
limit=50).json()
dict_mcd.append(data)
i += 1
with open('mcd.json', 'w') as f:
json.dump(dict_mcd, f)
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_bcrypt import Bcrypt
from flask_login import LoginManager
from nutritionix import Nutritionix
app = Flask(__name__)
#store database key to access
app.config['SECRET_KEY'] = '982b8f6e08e8cedff2c6deb24a40bbe6'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
#Create database
db = SQLAlchemy(app)
#Encrypt password
bcrypt = Bcrypt(app)
login_manager = LoginManager(app)
nix = Nutritionix(app_id=10908293, api_key="65ec9bee4c82e455f41d19c810f88f89")
@app.shell_context_processor
def make_shell_context():
return {'db': db, 'User': User}
from fitness import routes
# -*- coding: cp1252 -*- #to avoid encoding problem
from flask import Flask, request, render_template, url_for, redirect, session #importing flask to the environment and also required functions
from pyzomato import Pyzomato #importing zomato api
from nutritionix import Nutritionix #importing nutritionx api
import sys, os #importing miscellenous lib
app = Flask(__name__) #initialising flask framework as app
p = Pyzomato('b114ed71e5b2ec1fb505e869c891e157'
) #initialising zomato api and authenticating through api key
nix = Nutritionix(app_id="d6c8b53e",
api_key="3f98f4237dd0e647591d10d4c6c56450"
) #initialising nutritionx api and authentication
@app.route('/', methods=['POST', 'GET']) #defining url and method of action
def hello_world():
if request.method == 'GET': #fetching python file to user
return render_template('admin.html') #using admin html as template
elif request.method == 'POST':
username = request.form['username'] #getting input from users to login
password = request.form['password']
if username == "admin" and password == "admin": #verifing username and password
return redirect(
url_for('home')
) #if its correct its redirect to restaurant finding page
else:
kwargs = { #keyword arguments
'error':
"Invalid Username or Password", #sending error message to user if its wrong
}
return render_template(
import urllib2
import json
from nutritionix import Nutritionix
###################KEY INFO HERE FOR API ACCESS#################################
#you need to place an API key for Nutritionix here - provide one here below
#nx = Nutritionix (api_key = "daee2f4c8cc606f01466792b71d9a431", app_id = "1634d1d7")
### this is the second api key cuz, the first got overused
nx = Nutritionix(app_id="3df3337e", api_key="cff8d58ebc11131a0cd7f28a5432a60f")
###third api
#nx = Nutritionix(app_id = "249937bb", api_key="5cfcf8a5dd2fcfa9f21200c6bf1c6906")
###fourth api
#nx = Nutritionix(app_id = "4e647fd6", api_key="cc628ece2798dcaa546f55a929dc7e82")
###fifth api
#nx = Nutritionix(app_id = "4e647fd6", api_key="3c88e9d79929999f619fe935ceda1fb1")
################################################################################
####### Helper Functions #######
#compares the item-name to find measurement words
def compare(item, measureu):
temp = item["fields"]["item_name"].split()
if measureu in temp:
return True
return False
#returns amount from Nutritionix database
from nutritionix import Nutritionix
nix = Nutritionix(app_id="a43c505b",
api_key="ce2e2ad8e38bbf9dbb2043575c591179")
a = nix.search("pizza", results="0:1").json()
b = a['hits']
_id = b[0]
calorie = nix.item(id=_id['_id']).json()['nf_calories']
from app import app
from flask import render_template, request
import os
from nutritionix import Nutritionix
nix = Nutritionix(app_id=os.environ.get('NUTRITIONIX_API_ID'),
api_key=os.environ.get('NUTRITIONIX_API_KEY'))
@app.route('/', methods=['GET', 'POST'])
@app.route('/index')
def index():
return render_template("index.html", title='Search Page')
@app.route('/search', methods=['GET', 'POST'])
def search():
search_term = request.args.get('search_term')
brand_search = nix.brand().search(query=search_term).json()
return render_template("brand_results.html",
title='Brand Results',
results=brand_search['hits'])
@app.route('/results')
def results():
brand = request.args.get('id')
results = []
import requests
import server
from requests.auth import HTTPBasicAuth
from flask import Flask, request, jsonify,redirect, url_for, send_from_directory
from flask import render_template
from nutritionix import Nutritionix
from nutrientCalculator import *
from mealPlan import getMealPlan
from login import *
from journal import *
app = Flask(__name__)
username = ""
db = server.get_db()
nix = Nutritionix(app_id='7f770e5d', api_key='dae4065c600b6b161789a27471167ccd') #make these env variables later
url = 'https://api.nutritionix.com/v1_1/search?'
def set_username(new_username):
global username
username = new_username
@app.route("/results")
def results():
return render_template('results.html')
@app.route("/links")
def links():
return render_template('links.html')
@app.route("/login",methods=['POST','GET'])
from nutritionix import Nutritionix
nix = Nutritionix(app_id="7cb9887a",
api_key="a4d7fd53cc8bfde145020068f99b204d")
from twisted.internet.protocol import Protocol, Factory
from twisted.internet import reactor
class IphoneChat(Protocol):
def connectionMade(self):
#self.transport.write("""connected""")
self.factory.clients.append(self)
print "clients are ", self.factory.clients
def connectionLost(self, reason):
self.factory.clients.remove(self)
def dataReceived(self, data):
print "data is ", data
a = data.split(':')
if len(a) > 1:
command = a[0]
content = a[1].rstrip()
msg = ""
if command == "iam":
self.name = content
msg = self.name + " has joined"
elif command == "msg":
msg = self.name + ": " + content
with open('lipton.jpg', 'rb') as f:
response = api.image_request(f, 'lipton.jpg', {
'image_request[locale]': 'en-US',
})
status = api.image_response(response['token'])
if status['status'] != cloudsight.STATUS_NOT_COMPLETED:
# Done!
pass
status = api.wait(response['token'], timeout=30)
from nutritionix import Nutritionix
nix = Nutritionix(app_id="76986486",
api_key="28882f3d105c4c9e3222a05eeafd049a")
result = nix.search('pizza').json()
