app.py

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.")