Delete app.py

app.py

@@ -1,359 +0,0 @@
-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(self, image_path):
-    with open(image_path, "rb") as image_file:
-        return base64.b64encode(image_file.read()).decode('utf-8')
-
-def get_recipe(recipe_name: str) -> Recipe:
-    groq_models = ["llama3-groq-70b-8192-tool-use-preview", "llama-3.1-70b-versatile", "llama3-70b-8192"]
-    while True:
-        try:
-            for api_key in api_keys:
-                 client = Groq(api_key=api_key)
-                 for groq_model in groq_models:
-                    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
-
-
-
-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"]
-    while True:
-        try:
-            for api_key in api_keys:
-                client = Groq(api_key=api_key)
-                for groq_model in groq_models:
-                    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
-
-
-def get_explanation(base64_image):
-
-    while True:
-
-
-        try:
-            for api_key in api_keys:
-                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"""
-                                },
-                                {
-                                    "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
-
-
-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 
-
-    ]
-    }
-    '''
-    while True:
-        try:
-            for api_key in api_keys:
-                client = Groq(api_key=api_key)
-
-                for groq_model in groq_models:
-
-                    chat_completion = client.chat.completions.create(
-                        messages=[
-                            {
-                                "role": "user",
-                                "content": f'''
-                                 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
-
-
-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())
-
-    context = get_explanation(file_path)
-    result = generate_recipe_info(context)
-    json_result = json.loads(result)
-
-    return {
-        "Response": json_result
-    }
-
-
-# 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!"}