Spaces:
Sleeping
Sleeping
| import os | |
| import re | |
| import ast | |
| import json | |
| import pickle | |
| import secrets | |
| import random | |
| import datetime | |
| import pandas as pd | |
| from huggingface_hub import login, InferenceClient | |
| from sklearn.metrics.pairwise import cosine_similarity | |
| import streamlit as st | |
| st.set_page_config(layout="wide") | |
| # Load environment token | |
| login(token=os.getenv("TOKEN")) | |
| # Load data from pickled files | |
| with open('cv.pkl', 'rb') as file: | |
| cv = pickle.load(file) | |
| with open('vectors.pkl', 'rb') as file: | |
| vectors = pickle.load(file) | |
| with open('items_dict.pkl', 'rb') as file: | |
| items_dict = pd.DataFrame.from_dict(pickle.load(file)) | |
| mode = st.toggle(label="MART") | |
| # Utility functions | |
| def preprocess_text(text): | |
| text = re.sub(r'[^a-zA-Z\s]', '', text) | |
| text = re.sub(r'\s+', ' ', text).strip() | |
| return text.lower() | |
| def get_recommendations(user_description, count_vectorizer, count_matrix): | |
| user_description = preprocess_text(user_description) | |
| user_vector = count_vectorizer.transform([user_description]) | |
| cosine_similarities = cosine_similarity(user_vector, count_matrix).flatten() | |
| similar_indices = cosine_similarities.argsort()[::-1] | |
| return similar_indices | |
| def create_detailed_prompt(user_direction, exclusions, serving_size, difficulty): | |
| prompt_template = { | |
| "Quick & Easy": ( | |
| "Provide a 'Quick and Easy' recipe for {user_direction} that excludes {exclusions} and has a serving size of {serving_size}. " | |
| "It should require as few ingredients as possible and should be ready in as little time as possible. " | |
| "The steps should be simple, and the ingredients should be commonly found in a household pantry. " | |
| "Provide a detailed ingredient list and step-by-step guide that explains the instructions to prepare in detail." | |
| ), | |
| "Intermediate": ( | |
| "Provide a classic recipe for {user_direction} that excludes {exclusions} and has a serving size of {serving_size}. " | |
| "The recipe should offer a bit of a cooking challenge but should not require professional skills. " | |
| "The recipe should feature traditional ingredients and techniques that are authentic to its cuisine. " | |
| "Provide a detailed ingredient list and step-by-step guide that explains the instructions to prepare in detail." | |
| ), | |
| "Professional": ( | |
| "Provide an advanced recipe for {user_direction} that excludes {exclusions} and has a serving size of {serving_size}. " | |
| "The recipe should push the boundaries of culinary arts, integrating unique ingredients, advanced cooking techniques, and innovative presentations. " | |
| "The recipe should be able to be served at a high-end restaurant or would impress at a gourmet food competition. " | |
| "Provide a detailed ingredient list and step-by-step guide that explains the instructions to prepare in detail." | |
| ) | |
| } | |
| return prompt_template[difficulty].format( | |
| user_direction=user_direction, | |
| exclusions=exclusions, | |
| serving_size=serving_size | |
| ) | |
| def generate_recipe(user_inputs): | |
| with st.spinner('Building the perfect recipe...'): | |
| prompt = create_detailed_prompt(user_inputs['user_direction'], user_inputs['exclusions'], | |
| user_inputs['serving_size'], user_inputs['difficulty']) | |
| functions = [ | |
| { | |
| "name": "provide_recipe", | |
| "description": "Provides a detailed recipe strictly adhering to the user input/specifications, especially ingredient exclusions and the recipe difficulty", | |
| "parameters": { | |
| "type": "object", | |
| "properties": { | |
| "name": {"type": "string", "description": "A creative name for the recipe"}, | |
| "description": {"type": "string", "description": "a brief one-sentence description of the provided recipe"}, | |
| "ingredients": { | |
| "type": "array", | |
| "items": { | |
| "type": "object", | |
| "properties": {"name": {"type": "string", "description": "Quantity and name of the ingredient"}} | |
| } | |
| }, | |
| "instructions": { | |
| "type": "array", | |
| "items": { | |
| "type": "object", | |
| "properties": { | |
| "step_number": {"type": "number", "description": "The sequence number of this step"}, | |
| "instruction": {"type": "string", "description": "Detailed description of what to do in this step"} | |
| } | |
| } | |
| } | |
| }, | |
| "required": ["name", "description", "ingredients", "instructions"] | |
| } | |
| } | |
| ] | |
| generate_kwargs = dict( | |
| temperature=0.9, | |
| max_new_tokens=10000, | |
| top_p=0.9, | |
| repetition_penalty=1.0, | |
| do_sample=True, | |
| ) | |
| prompt += f"\nPlease format the output in JSON. The JSON should include fields for 'name', 'description', 'ingredients', and 'instructions', with each field structured as described below.\n\n{json.dumps(functions)}" | |
| response = client.text_generation(prompt, **generate_kwargs) | |
| st.session_state.recipe = response | |
| st.session_state.recipe_saved = False | |
| def show_recipe(recipe): | |
| with st.spinner("HANG TIGHT, RECIPE INCOMING..."): | |
| name_and_dis = f'# {recipe["name"]}\n\n{recipe["description"]}\n\n' | |
| ingredients = '## Ingredients:\n' | |
| instructions = '## Instructions:\n' | |
| for instruction in recipe["instructions"]: | |
| instructions += f"{instruction['step_number']}. {instruction['instruction']}\n" | |
| st.write(name_and_dis) | |
| col01, col02 = st.columns(2) | |
| with col01: | |
| cont = st.container(border=True, height=500) | |
| cont.write(ingredients) | |
| for j, i in enumerate(recipe["ingredients"]): | |
| cont.selectbox(i['name'], | |
| options=items_dict.iloc[get_recommendations(i['name'], cv, vectors)]["PRODUCT_NAME"].values, | |
| key=f"selectbox_{j}_{i['name']}{random.random()*100}") | |
| with col02: | |
| cont = st.container(border=True, height=500) | |
| cont.write(instructions) | |
| def clear_inputs(): | |
| st.session_state.user_direction = None | |
| st.session_state.exclusions = None | |
| st.session_state.serving_size = 2 | |
| st.session_state.selected_difficulty = "Quick & Easy" | |
| st.session_state.recipe = None | |
| def create_safe_filename(recipe_name): | |
| safe_name = recipe_name.lower().replace(" ", "_") | |
| safe_name = re.sub(r"[^a-zA-Z0-9_]", "", safe_name) | |
| safe_name = safe_name[:50] if len(safe_name) > 50 else safe_name | |
| unique_token = secrets.token_hex(8) | |
| return f"{unique_token}_{safe_name}" | |
| def save_recipe(): | |
| with st.spinner('WAIT SAVING YOUR DISH...'): | |
| filename = create_safe_filename(recipe["name"]) | |
| os.makedirs('data', exist_ok=True) | |
| with open(f'./data/{filename}.pkl', 'wb') as f: | |
| pickle.dump(recipe, f) | |
| st.session_state.recipe_saved = True | |
| def load_saved_recipes_from_pickle(directory_path): | |
| os.makedirs('data', exist_ok=True) | |
| recipes = [] | |
| for filename in os.listdir(directory_path): | |
| if filename.endswith('.pkl'): | |
| with open(os.path.join(directory_path, filename), 'rb') as file: | |
| recipe = pickle.load(file) | |
| recipes.append(recipe) | |
| return recipes | |
| # Main UI logic | |
| if not mode: | |
| if 'current_tab' not in st.session_state: | |
| st.session_state.current_tab = 'COOK' | |
| cook, saved = st.tabs(['COOK', 'SAVED']) | |
| if cook: | |
| st.session_state.current_tab = 'COOK' | |
| if saved: | |
| st.session_state.current_tab = 'SAVED' | |
| if st.session_state.current_tab == 'COOK': | |
| with cook: | |
| client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1") | |
| if 'recipe' not in st.session_state: | |
| st.session_state.recipe = None | |
| if 'recipe_saved' not in st.session_state: | |
| st.session_state.recipe_saved = None | |
| if 'user_direction' not in st.session_state: | |
| st.session_state.user_direction = None | |
| if 'serving_size' not in st.session_state: | |
| st.session_state.serving_size = 2 | |
| if 'selected_difficulty' not in st.session_state: | |
| st.session_state.selected_difficulty = "Quick & Easy" | |
| if 'exclusions' not in st.session_state: | |
| st.session_state.exclusions = None | |
| st.title("Let's get cooking") | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| st.session_state.user_direction = st.text_area( | |
| "What do you want to cook? Describe anything - a dish, cuisine, event, or vibe.", | |
| value=st.session_state.user_direction, | |
| placeholder="quick snack, asian style bowl with either noodles or rice, something italian", | |
| ) | |
| with col2: | |
| st.session_state.serving_size = st.number_input( | |
| "How many servings would you like to cook?", | |
| min_value=1, | |
| max_value=100, | |
| value=st.session_state.serving_size, | |
| step=1 | |
| ) | |
| difficulty_dictionary = { | |
| "Quick & Easy": { | |
| "description": "Easy recipes with straightforward instructions. Ideal for beginners or those seeking quick and simple cooking.", | |
| }, | |
| "Intermediate": { | |
| "description": "Recipes with some intricate steps that invite a little challenge. Perfect for regular cooks wanting to expand their repertoire with new ingredients and techniques.", | |
| }, | |
| "Professional": { | |
| "description": "Complex recipes that demand a high level of skill and precision. Suited for seasoned cooks aspiring to professional-level sophistication and creativity.", | |
| } | |
| } | |
| st.session_state.selected_difficulty = st.radio( | |
| "Choose a difficulty level for your recipe.", | |
| list(difficulty_dictionary.keys()), | |
| index=list(difficulty_dictionary.keys()).index(st.session_state.selected_difficulty), | |
| format_func=lambda x: f"{x}: {difficulty_dictionary[x]['description']}" | |
| ) | |
| st.session_state.exclusions = st.text_area( | |
| "Any ingredients you want to exclude?", | |
| value=st.session_state.exclusions, | |
| placeholder="gluten, dairy, nuts, cilantro", | |
| ) | |
| fancy_exclusions = "" | |
| if st.session_state.selected_difficulty == "Professional": | |
| exclude_fancy = st.checkbox( | |
| "Exclude cliche professional ingredients? (gold leaf, truffle, edible flowers, microgreens)", | |
| value=True) | |
| if exclude_fancy: | |
| fancy_exclusions = "gold leaf, truffle, edible flowers, microgreens, gold dust" | |
| user_inputs = { | |
| "user_direction": st.session_state.user_direction, | |
| "exclusions": f"{st.session_state.exclusions}, {fancy_exclusions}".strip(", "), | |
| "serving_size": st.session_state.serving_size, | |
| "difficulty": st.session_state.selected_difficulty | |
| } | |
| button_cols_submit = st.columns([1, 1, 4]) | |
| with button_cols_submit[0]: | |
| st.button(label='Submit', on_click=generate_recipe, kwargs=dict(user_inputs=user_inputs), type="primary", | |
| use_container_width=True) | |
| with button_cols_submit[1]: | |
| st.button(label='Reset', on_click=clear_inputs, type="secondary", use_container_width=True) | |
| with button_cols_submit[2]: | |
| st.empty() | |
| if st.session_state.recipe is not None: | |
| st.divider() | |
| recipe = json.loads(st.session_state.recipe) | |
| if not st.session_state.recipe_saved: | |
| show_recipe(recipe) | |
| recipe['timestamp'] = str(datetime.datetime.now()) | |
| disable_button = st.session_state.recipe_saved | |
| button_cols_save = st.columns([1, 1, 4]) | |
| with button_cols_save[0]: | |
| st.button("Save Recipe", on_click=save_recipe, disabled=disable_button, type="primary") | |
| with button_cols_save[1]: | |
| st.empty() | |
| with button_cols_save[2]: | |
| st.empty() | |
| if st.session_state.recipe_saved: | |
| st.success("Recipe Saved!") | |
| elif st.session_state.current_tab == 'SAVED': | |
| with saved: | |
| st.title("Saved Recipes") | |
| with st.spinner('LOADING YOUR RECIPE...'): | |
| directory_path = 'data' | |
| recipes = load_saved_recipes_from_pickle(directory_path) | |
| cols = st.columns([4, 1]) | |
| with cols[1]: | |
| user_sort = st.selectbox("Sort", ('Recent', 'Oldest', 'A-Z', 'Z-A', 'Random')) | |
| if user_sort == 'Recent': | |
| recipes.sort(key=lambda x: x['timestamp'], reverse=True) | |
| elif user_sort == 'Oldest': | |
| recipes.sort(key=lambda x: x['timestamp']) | |
| elif user_sort == 'A-Z': | |
| recipes.sort(key=lambda x: x['name']) | |
| elif user_sort == 'Z-A': | |
| recipes.sort(key=lambda x: x['name'], reverse=True) | |
| elif user_sort == 'Random': | |
| random.shuffle(recipes) | |
| with cols[0]: | |
| user_search = st.selectbox("Search Recipes", [""] + [recipe['name'] for recipe in recipes]) | |
| st.write("") # just some space | |
| if user_search: | |
| st.divider() | |
| filtered_recipes = [recipe for recipe in recipes if recipe['name'] == user_search] | |
| if filtered_recipes: | |
| show_recipe(filtered_recipes[0]) | |
| else: | |
| st.write("No recipe found.") | |