app.py

from pydantic import BaseModel
from pymongo import MongoClient
from urllib.parse import quote_plus
import uuid
from typing import List
import json
from fastapi import FastAPI, File, UploadFile, HTTPException
import os
import base64
from groq import Groq
import time

api_keys = ['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', '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']

# MongoDB connection setup
def get_mongo_client():
    password = quote_plus("momimaad@123")  # Change this to your MongoDB password
    mongo_uri = f"mongodb+srv://hammad:{password}@cluster0.2a9yu.mongodb.net/"
    return MongoClient(mongo_uri)

db_client = get_mongo_client()
db = db_client["recipe"]
user_collection = db["user_info"]

# Pydantic models for user data
class User(BaseModel):
    first_name: str
    last_name: str
    email: str
    password: str

class UserData(BaseModel):
    email: str
    password: str

class UserToken(BaseModel):
    token: str

class RecipeData(BaseModel):
    name: str

class AltrecipeData(BaseModel):
    recipe_name: str
    dietary_restrictions: str
    allergies: List

class Ingredient(BaseModel):
    name: str
    quantity: str


class Recipe(BaseModel):
    recipe_name: str
    ingredients: List[Ingredient]
    directions: List[str]


class get_recipe_name(BaseModel):
    recipe_name: List[str]
    ingredients: List[List[str]]

# Data model for LLM to generate
class Alternative_Ingredient(BaseModel):
    name: str
    quantity: str

class Alternative_Recipe(BaseModel):
    recipe_name: str
    alternative_ingredients: List[Alternative_Ingredient]
    alternative_directions: List[str]

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')
class RecipeGenerationError(Exception):
    """Custom exception for recipe generation errors."""
    pass

def get_recipe(recipe_name: str) -> Recipe:

    groq_models = ["llama3-groq-70b-8192-tool-use-preview", "llama-3.1-70b-versatile", "llama3-70b-8192"]

    for api_key in api_keys:
        try:
             client = Groq(api_key=api_key)
             for groq_model in groq_models:
                 try:
                    chat_completion = client.chat.completions.create(
                        messages=[
                            {
                                "role": "system",
                                "content": f"""Your are an expert agent to generate a recipes with proper and corrected ingredients and direction. Your directions should be concise and to the point and dont explain any irrelevant text.
                                You are a recipe database that outputs recipes in JSON.\n
                              The JSON object must use the schema: {json.dumps(Recipe.model_json_schema(), indent=2)}""",
                            },
                            {
                                "role": "user",
                                "content": f"Fetch a recipe for {recipe_name}",
                            },
                        ],
                        model=groq_model,
                        temperature=0,
                        # Streaming is not supported in JSON mode
                        stream=False,
                        # Enable JSON mode by setting the response format
                        response_format={"type": "json_object"},
                    )
                    return Recipe.model_validate_json(chat_completion.choices[0].message.content)

                 except Exception as e:
                     time.sleep(2)
                     continue


        except Exception as e:
            time.sleep(2)
            continue
    raise RecipeGenerationError("Server Error Try after some time.")


def Suggest_ingredient_alternatives(recipe_name: str, dietary_restrictions: str, allergies: List) -> Alternative_Recipe:
    groq_models = ["llama3-groq-70b-8192-tool-use-preview", "llama-3.1-70b-versatile", "llama3-70b-8192"]

    for api_key in api_keys:
        try:
            client = Groq(api_key=api_key)

            for groq_model in groq_models:
                try:
                    chat_completion = client.chat.completions.create(
                        messages=[
                            {
                                "role": "system",
                                "content": f"""
                                 You are an expert agent to suggest alternatives for specific allergies ingredients for the provided recipe {recipe_name}.
                
                                Please take the following into account:
                                - If the user has dietary restrictions, suggest substitutes that align with their needs (e.g., vegan, gluten-free, etc.) in alternative_directions and your alternative_directions should be concise and to the point.
                                -In ingredient you will recommend the safe ingredient for avoid any allergy and dietary restriction.
                                - Consider the following allergies {allergies} and recommend the safe ingredient to avoid this allergies.
                
                                recipe_name: {recipe_name}
                                Dietary Restrictions: {dietary_restrictions}
                                Allergies: {', '.join(allergies)}
                
                                You are a recipe database that outputs alternative recipes to avoid allergy and dietary_restrictions in JSON.\n
                                The JSON object must use the schema: {json.dumps(Alternative_Recipe.model_json_schema(), indent=2)}""",
                            },
                            {
                                "role": "user",
                                "content": f"""Fetch a alternative recipe for recipe_name: {recipe_name}
                                Dietary Restrictions: {dietary_restrictions}
                                Allergies: {', '.join(allergies)}""",
                            },
                        ],
                        model=groq_model,
                        temperature=0,
                        # Streaming is not supported in JSON mode
                        stream=False,
                        # Enable JSON mode by setting the response format
                        response_format={"type": "json_object"},
                    )
                    return Alternative_Recipe.model_validate_json(chat_completion.choices[0].message.content)
                except Exception as e:
                    time.sleep(2)
                    continue
        except Exception as e:
            time.sleep(2)
            continue

    raise RecipeGenerationError("Server Error Try after some time.")


def get_explanation(base64_image):

    api_keys = [
        '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',
        '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',
        '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',
        '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',
        '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'
    ]

    for api_key in api_keys:
        try:
            client = Groq(api_key=api_key)
            completion = client.chat.completions.create(
                model="llama-3.2-90b-vision-preview",
                messages=[
                    {
                        "role": "user",
                        "content": [
                            {
                                "type": "text",
                                "text": """Explain the following image in detail with the recipes names if it were present in images with expanation of ingredients. If there is one rcipe kindly mention it and if there are many then mention the total number of recipes and also mention their names and i want correct explanation."""
                            },
                            {
                                "type": "image_url",
                                "image_url": {
                                    "url": f"data:image/jpeg;base64,{base64_image}"
                                }
                            }
                        ]
                    }
                ],
                temperature=1,
                max_tokens=1024,
                top_p=1,
                stream=False,
                stop=None,
            )

            return completion.choices[0].message.content

        except Exception as e:
            time.sleep(2)
            continue
    raise RecipeGenerationError("Server Error Try after some time.")


def generate_recipe_info(context):
    groq_models = ["llama3-groq-70b-8192-tool-use-preview", "llama-3.1-70b-versatile", "llama3-70b-8192"]
    output_format = '''
    Kindly generate the following json output format and iwant this format same to same dont change anything and add irrelevant text 
    Generate a output according to json format:

    {'recipes': [it can be empty if there is no data about recipes in context and it conatin many recipes if there are multiple etc for example 
    {'recipe_name': '',
    'ingredients':[only three to four just or minimum]},
     {'recipe_name': '',
    'ingredients':[only three to four just or minimum]},
    {'recipe_name': '',
    'ingredients':[only three to four just or minimum]},
    so on 

    ]
    }
    '''

    for api_key in api_keys:
        try:
            client = Groq(api_key=api_key)
            for groq_model in groq_models:
                try:
                    chat_completion = client.chat.completions.create(
                        messages=[
                            {
                                "role": "user",
                                "content": f'''
                                Kindly analyze if there is one recipe then mention one recipe in json if multiple then according to it generate  a json.
                                 You are an expert agent to analyze the following context and find out recipes name with proper ingredients and i want the out[ut according to following json format and dont need to change anything.
                                 JSON OUTPUT FORMAT: {output_format}
                                 Consider the followng contexto answer to answer
                                 Context:
                             {context}
                                ''' + output_format
                            }
                        ],
                        temperature=0,
                        # Streaming is not supported in JSON mode
                        stream=False,
                        # Enable JSON mode by setting the response format
                        response_format={"type": "json_object"},
                        model=groq_model,
                    )

                    return chat_completion.choices[0].message.content
                except Exception as e:
                    time.sleep(2)
                    continue


        except Exception as e:
            time.sleep(2)
            continue
    raise RecipeGenerationError("Server Error Try after some time.")


app = FastAPI()

@app.post("/get_recipe/{token}")
async def get_recipe_response(token: str, recipe_user: RecipeData):
    try:
        user = user_collection.find_one({"token": token})
        if not user:
            raise HTTPException(status_code=401, detail="Invalid token")

        # Find user by email
        recipe_name = recipe_user.name
        response = get_recipe(recipe_name)
        return {
            "Response": response
        }
    except RecipeGenerationError as e:
        # Return a custom error response if the RecipeGenerationError is raised
        raise HTTPException(status_code=500, detail=str(e))


@app.post("/get_recipe_alternative/{token}")
async def get_alternative_recipe_response(token: str, altrecipe_user: AltrecipeData):
    try:
        user = user_collection.find_one({"token": token})
        if not user:
            raise HTTPException(status_code=401, detail="Invalid token")

        response = Suggest_ingredient_alternatives(altrecipe_user.recipe_name, altrecipe_user.dietary_restrictions, altrecipe_user.allergies)
        return {
            "Response": response
        }
    except RecipeGenerationError as e:
        # Return a custom error response if the RecipeGenerationError is raised
        raise HTTPException(status_code=500, detail=str(e))



# Directory to save uploaded images
UPLOAD_DIR = "uploads"

# Ensure the upload directory exists
os.makedirs(UPLOAD_DIR, exist_ok=True)


# Endpoint to upload an image
@app.post("/upload-image/{token}")
async def upload_image(token: str, file: UploadFile = File(...)):
    try:

        user = user_collection.find_one({"token": token})
        if not user:
            raise HTTPException(status_code=401, detail="Invalid token")

        # Validate the file type
        if not file.filename.lower().endswith(('.png', '.jpg', '.jpeg')):
            raise HTTPException(status_code=400, detail="Invalid file type. Only PNG, JPG, and JPEG are allowed.")

        # Create a file path for saving the uploaded file
        file_path = os.path.join(UPLOAD_DIR, file.filename)

        # Save the file
        with open(file_path, "wb") as buffer:
            buffer.write(await file.read())

        base64_image = encode_image(file_path)
        context = get_explanation(base64_image)
        result = generate_recipe_info(context)
        json_result = json.loads(result)

        return {
            "Response": json_result
        }
    except RecipeGenerationError as e:
        # Return a custom error response if the RecipeGenerationError is raised
        raise HTTPException(status_code=500, detail=str(e))


# Endpoint to register a new user
@app.post("/register")
async def register_user(user: User):
    # Check if user already exists
    existing_user = user_collection.find_one({"email": user.email})
    if existing_user:
        raise HTTPException(status_code=400, detail="Email already registered")

    # Create user data
    user_data = {
        "first_name": user.first_name,
        "last_name": user.last_name,
        "email": user.email,
        "password": user.password,  # Store plaintext password (not recommended in production)
    }

    # Insert the user data into the user_info collection
    result = user_collection.insert_one(user_data)
    return {"msg": "User registered successfully", "user_id": str(result.inserted_id)}

# Endpoint to check user credentials and generate a token
@app.post("/get_token")
async def check_credentials(user: UserData):
    # Find user by email
    existing_user = user_collection.find_one({"email": user.email})

    # Check if user exists and password matches
    if not existing_user or existing_user["password"] != user.password:
        raise HTTPException(status_code=401, detail="Invalid email or password")

    # Generate a UUID token
    token = str(uuid.uuid4())

    # Update the user document with the token
    user_collection.update_one({"email": user.email}, {"$set": {"token": token}})

    return {
        "first_name": existing_user["first_name"],
        "last_name": existing_user["last_name"],
        "token": token,
    }


@app.get("/")
async def root():
    return {"message": "API is up and running!"}