Upload app.py

app.py

@@ -0,0 +1,198 @@
+from fastapi import FastAPI, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+import base64
+from groq import Groq
+import shutil
+import os
+
+app = FastAPI()
+
+# Initialize Groq API with your API key
+client = Groq(api_key='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')
+
+# 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",
+        messages=[
+            {"role": "system", "content": prompt},
+            {"role": "user", "content": f"Meal Name: {meal_name}"}
+        ],
+        temperature=1,
+        max_tokens=2048,
+        top_p=1,
+        stream=True,
+        stop=None,
+    )
+
+    # 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!"}