Update app.py

app.py

@@ -1,198 +1,348 @@
-from fastapi import FastAPI, UploadFile, HTTPException
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel, Field
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from pymongo import MongoClient
+from urllib.parse import quote_plus
+import uuid
+from typing import List, Optional
+import json
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import HTMLResponse
+import os
 import base64
 from groq import Groq
-import shutil
-import os
+# Initialize Groq client
+client = Groq(api_key='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')
 
-app = FastAPI()
+# 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)
 
-# Initialize Groq API with your API key
-client = Groq(api_key='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')
+db_client = get_mongo_client()
+db = db_client["recipe"]
+user_collection = db["user_info"]
 
-# Pydantic models for input validation
-class RecipeRequest(BaseModel):
-    meal_name: str = Field(..., description="Name of the meal to generate a recipe for")
-
-class IngredientAlternativesRequest(BaseModel):
-    ingredients: list[str] = Field(..., description="List of ingredients to suggest alternatives for")
-    dietary_restrictions: str = Field(..., description="Dietary restrictions, if any")
-    allergies: list[str] = Field(..., description="List of allergies to consider")
-
-
-# Helper function to encode the image to base64
-def encode_image(image_path: str) -> str:
-    try:
-        with open(image_path, "rb") as image_file:
-            return base64.b64encode(image_file.read()).decode('utf-8')
-    except FileNotFoundError:
-        raise HTTPException(status_code=404, detail="Image not found.")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error encoding image: {str(e)}")
-
-
-# POST /infer (Image inference route)
-@app.post("/infer")
-async def infer_image(file: UploadFile):
-    """
-    Perform inference on an uploaded image and return the result.
-    """
-    try:
-        # Save the uploaded image to a temporary file
-        temp_image_path = f"temp_{file.filename}"
-        with open(temp_image_path, "wb") as buffer:
-            shutil.copyfileobj(file.file, buffer)
-
-        # Encode the image to base64
-        base64_image = encode_image(temp_image_path)
-
-        # Prepare the query and image data for Groq API
-        chat_completion = client.chat.completions.create(
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": "What are the ingredients used in this dish?. Do not add any explanation just write the names of the ingredients. Write the name of the dish and then write the ingredients used"},
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:image/jpeg;base64,{base64_image}",
-                            },
-                        },
-                    ],
-                }
-            ],
-            model="llama-3.2-11b-vision-preview"
-        )
-
-        # Clean up the temporary image file
-        os.remove(temp_image_path)
-
-        # Get the response from the API and return the result
-        result = chat_completion.choices[0].message.content
-        return JSONResponse(status_code=200, content={"result": result})
-
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error during inference: {str(e)}")
-
-
-# POST /recipes (Recipe generation route)
-@app.post("/recipes")
-async def generate_recipe(request: RecipeRequest):
-    """
-    Generate a recipe based on the meal name.
-    """
-    try:
-        # Generate the recipe based on the meal name
-        recipe = Generate_recipe(request.meal_name)
-        return JSONResponse(status_code=200, content={"recipe": recipe})
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error generating recipe: {str(e)}")
-
-
-# Helper function to generate a recipe based on meal name
-def Generate_recipe(meal_name: str) -> str:
-    prompt = f"""
-    You are a recipe-creating agent. Your task is to create a recipe based on the meal name provided by the user.
-    The recipe should be detailed and include the following information:
-
-    - A list of ingredients required for the meal.
-    - Step-by-step cooking instructions.
-    - Approximate preparation and cooking time.
-    - Serving suggestions or tips for best results.
-
-    Please process the user's meal name and create the appropriate recipe.
-
-    Meal Name: {meal_name}
-    """
-
-    # Create a chat completion request using the llama-3.1-70b-versatile model
-    completion = client.chat.completions.create(
-        model="llama-3.1-70b-versatile",
+# 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]
+
+
+# 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 get_recipe(recipe_name: str) -> Recipe:
+    chat_completion = client.chat.completions.create(
         messages=[
-            {"role": "system", "content": prompt},
-            {"role": "user", "content": f"Meal Name: {meal_name}"}
+            {
+                "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}",
+            },
         ],
-        temperature=1,
-        max_tokens=2048,
-        top_p=1,
-        stream=True,
-        stop=None,
+        model="llama3-8b-8192",
+        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)
+
+
+
+
+
+def Suggest_ingredient_alternatives(recipe_name: str, dietary_restrictions: str, allergies: List) -> Alternative_Recipe:
+    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="llama3-8b-8192",
+        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)
+
+
+def get_status(content):
+    chat_completion = client.chat.completions.create(
+        messages=[
+            {
+                "role": "system",
+                "content": """Your are an expert agent to status yes if any kind of recipe dish present in explanation other no
+
+                Json output format:
+                {'status':return'yes' if any dish present in expalantion return 'no' if not dish present in image}
+                """,
+            },
+            {
+                "role": "user",
+                "content": f"Image Explanation {content}",
+            },
+        ],
+        model="llama3-groq-70b-8192-tool-use-preview",
+        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 chat_completion.choices[0].message.content
+
+# Function to encode the image
+def encode_image(image_path):
+  with open(image_path, "rb") as image_file:
+    return base64.b64encode(image_file.read()).decode('utf-8')
+
+def explain_image(base64_image):
+    text_query = '''
+    explain the image
+    '''
+    chat_completion = client.chat.completions.create(
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": text_query},
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{base64_image}",
+                        },
+                    },
+                ],
+
+            }
+        ],
+        model="llama-3.2-11b-vision-preview")
+    return chat_completion.choices[0].message.content
+
+
+class get_recipe_name(BaseModel):
+    recipe_name: List[str]
+    ingredients: List[List[str]]
+
+
+def generate_recipe_name(base64_image):
+    # Example of how the JSON should look to make it clearer
+    example_json_structure = {
+        "recipe_name": ["Chicken Karahi", "Pasta Alfredo"],
+        "ingredients": [
+            ["chicken", "tomatoes", "onion", "ginger", "garlic", "red chili pepper", "oil"],
+            ["pasta", "cream", "butter", "parmesan cheese", "garlic", "salt", "pepper"]
+        ]
+    }
+
+    # Generating the query prompt to ask for ingredients
+    text_query = f'''What are the ingredients used in these dishes? Do not add any explanation, just write the names of the ingredients in proper JSON according to the following format:
+    The JSON object must follow this schema:
+    {json.dumps(get_recipe_name.model_json_schema(), indent=2)}
+
+    Example format:
+    {json.dumps(example_json_structure, indent=2)}
+
+    Write the name of the dish and then write the ingredients used for each recipe.
+    '''
+
+    chat_completion = client.chat.completions.create(
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": text_query},
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{base64_image}",
+                        },
+                    },
+                ],
+
+            }
+        ],
+        response_format={"type": "json_object"},
+        model="llama-3.2-11b-vision-preview")
+    return json.loads(chat_completion.choices[0].message.content)
+
+
+
+
+
+app = FastAPI()
+
+
+
+
+@app.post("/get_recipe/{token}")
+async def get_recipe_response(token: str, recipe_user: RecipeData):
+    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
+    }
+
+@app.post("/get_recipe_alternative/{token}")
+async def get_alternative_recipe_response(token: str, altrecipe_user: AltrecipeData):
+    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
+    }
+
+
+# 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(...)):
+    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())
+
+    # Getting the base64 string
+    base64_image = encode_image(file_path)
+
+    status = get_status(explain_image(base64_image))
+    status_json = json.loads(status)
+    if status_json['status'].lower() == 'no':
+        response = {"recipe_name": [], 'ingredients': []}
+    else:
+        response = generate_recipe_name(base64_image)
+
+    return {
+        "Response": response
+    }
+
+
+# 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")
 
-    # Stream and collect the response from the model
-    recipe_result = ""
-    for chunk in completion:
-        recipe_result += chunk.choices[0].delta.content or ""
-
-    return recipe_result
-
-
-# POST /ingredients/alternatives (Ingredient alternatives route)
-@app.post("/ingredients/alternatives")
-async def suggest_ingredient_alternatives(request: IngredientAlternativesRequest):
-    """
-    Suggest alternatives for specific ingredients based on dietary restrictions and allergies.
-    """
-    try:
-        # Generate ingredient alternatives
-        alternatives = Suggest_ingredient_alternatives(
-            request.ingredients, 
-            request.dietary_restrictions, 
-            request.allergies
-        )
-        return JSONResponse(status_code=200, content={"alternatives": alternatives})
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error suggesting ingredient alternatives: {str(e)}")
-
-
-# Helper function to suggest ingredient alternatives based on user input
-def Suggest_ingredient_alternatives(ingredients, dietary_restrictions, allergies):
-    alternative_suggestions = ""
-
-    # Iterate over each ingredient to provide an alternative
-    for ingredient in ingredients:
-        prompt = f"""
-        You are an ingredient substitution agent. Your task is to suggest alternatives for specific ingredients based on the user's input, particularly for biryani recipes.
-
-        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.).
-        - Consider the following allergies and suggest safe alternatives: {', '.join(allergies)}.
-        - The alternative should be commonly available, and you should provide options if multiple substitutes exist.
-        - Explain how the suggested alternative will impact the recipe, in terms of taste, texture, or cooking time.
-
-        Ingredient: {ingredient}
-        Dietary Restrictions: {dietary_restrictions}
-        Allergies: {', '.join(allergies)}
-        """
-
-        # Create a chat completion request using the llama-3.1-70b-versatile model
-        completion = client.chat.completions.create(
-            model="llama-3.1-70b-versatile",
-            messages=[
-                {"role": "system", "content": prompt},
-                {"role": "user", "content": f"Ingredient: {ingredient}, Dietary Restrictions: {dietary_restrictions}, Allergies: {', '.join(allergies)}"}
-            ],
-            temperature=1,
-            max_tokens=1024,
-            top_p=1,
-            stream=True,
-            stop=None,
-        )
-
-        # Collect the response for each ingredient
-        suggestion = ""
-        for chunk in completion:
-            suggestion += chunk.choices[0].delta.content or ""
-
-        # Append the suggestion to the final result
-        alternative_suggestions += f"Substitute suggestions for {ingredient}:\n{suggestion}\n{'-'*50}\n"
-
-    return alternative_suggestions
-
-
-# Root endpoint to check if the API is running
-@app.get("/")
-async def root():
-    return {"message": "API is running!"}
+    # 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,
+    }