new space

llm/image_description.py

@@ -0,0 +1,39 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import torch
+from PIL import Image
+
+model = AutoModelForCausalLM.from_pretrained(
+    "openbmb/MiniCPM-Llama3-V-2_5",
+    trust_remote_code=True
+)
+
+print(model)
+
+tokenizer = AutoTokenizer.from_pretrained(
+    "openbmb/MiniCPM-Llama3-V-2_5",
+    trust_remote_code=True
+)
+
+image = Image.open("fridge.JPG")
+prompt = "What is the main object shown in the image? Describe in less than 5 words, as a name for it."
+
+# First round chat 
+# question = "Tell me the model of this aircraft."
+msgs = [{'role': 'user', 'content': [image, prompt]}]
+
+answer = model.chat(
+    image=None,
+    msgs=msgs,
+    tokenizer=tokenizer
+)
+print(answer)
+
+
+# chat = model.chat(
+#     image=image, 
+#     question=prompt, 
+#     tokenizer=tokenizer,
+#     generate_args={"temperature": 0.8}
+# )
+
+# print(chat)

llm/inference.py

@@ -0,0 +1,119 @@
+from huggingface_hub import InferenceClient
+import nltk
+import re 
+import requests
+import os 
+
+api_key = os.getenv("HF_KEY")
+
+nltk.download('punkt_tab')
+nltk.download('averaged_perceptron_tagger')
+
+
+client = InferenceClient(api_key=api_key)
+
+
+def extract_product_info(text):
+    # Initialize result dictionary
+    result = {"brand": None, "model": None, "description": None, "price": None}
+
+    # Improved regex to prioritize currency-related patterns
+    price_match = re.search(
+        r'(\$\s?\d{1,3}(?:,\d{3})*(?:\.\d{2})?|(?:\d{1,3}(?:,\d{3})*(?:\.\d{2})?\s?(?:USD|usd|dollars|DOLLARS)))',
+        text
+    )
+    if price_match:
+        price = price_match.group().strip()
+        # Clean up the price format
+        if "$" in price or "USD" in price or "usd" in price:
+            result["price"] = re.sub(r'[^\d.]', '', price)  # Keep only digits and decimals
+        else:
+            result["price"] = price
+        # Remove the price part from the text to prevent it from being included in the brand/model extraction
+        text = text.replace(price_match.group(), "").strip()
+
+    # Tokenize the remaining text and tag parts of speech
+    tokens = nltk.word_tokenize(text)
+    pos_tags = nltk.pos_tag(tokens)
+
+    # Extract brand and model (Proper Nouns + Alphanumeric patterns)
+    brand_parts = []
+    model_parts = []
+    description_parts = []
+    
+    for word, tag in pos_tags:
+        if tag == 'NNP' or re.match(r'[A-Za-z0-9-]+', word):
+            if len(brand_parts) == 0:  # Assume the first proper noun is the brand
+                brand_parts.append(word)
+            else:  # Model number tends to follow the brand
+                model_parts.append(word)
+        else:
+            description_parts.append(word)
+    
+    # Assign brand and model to result dictionary
+    if brand_parts:
+        result["brand"] = " ".join(brand_parts)
+    if model_parts:
+        result["model"] = " ".join(model_parts)
+    
+    # Combine the remaining parts as description
+    result["description"] = " ".join(description_parts)
+
+    return result
+
+
+
+def extract_info(text):
+    API_URL = "https://api-inference.huggingface.co/models/google/flan-t5-large"
+    headers = {"Authorization": f"Bearer {api_key}"}
+    payload = {"inputs": f"From the given text, extract brand name, model number, description about it, and its average price in today's market. Give me back a python dictionary with keys as brand_name, model_number, desc, price. The text is {text}.",}
+    response = requests.post(API_URL, headers=headers, json=payload)
+    print('GOOGLEE LLM OUTPUTTTTTTT\n\n',response )
+    output = response.json()
+    print(output)
+
+
+
+def get_name(url, object):
+	messages = [
+		{
+			"role": "user",
+			"content": [
+				{
+					"type": "text",
+					"text": f"Is this a {object}?. Can you guess what it is and give me the closest brand it resembles to? or a model number? And give me its average price in today's market in USD. In output, give me its normal name, model name, model number and price. separated by commas. No description is needed." 
+				},
+				{
+					"type": "image_url",
+					"image_url": {
+						"url": url
+					}
+				}
+			]
+		}
+	]
+
+	completion = client.chat.completions.create(
+		model="meta-llama/Llama-3.2-11B-Vision-Instruct", 
+		messages=messages, 
+		max_tokens=500
+	)
+
+
+	print(f'\n\nNow output of LLM:\n')
+	llm_result = completion.choices[0].message['content']
+	print(llm_result)
+	print(f'\n\nThat is the output')
+     
+	result = extract_product_info(llm_result)
+	print(f'\n\nResult brand and price:{result}')
+    
+	# result2 = extract_info(llm_result)
+	# print(f'\n\nFrom Google llm:{result2}')
+
+	return result
+
+# url = "https://i.ibb.co/mNYvqDL/crop_39.jpg"
+# object="fridge"
+
+# get_name(url, object)

llm/upload_image.py

@@ -0,0 +1,39 @@
+import requests
+
+def upload_image_to_imgbb(image_path, api_key="0e7fb6d183b8db925812dee230f71079"):
+    """
+    Uploads an image to ImgBB and returns the URL.
+
+    :param image_path: Path to the local image
+    :param api_key: ImgBB API key
+    :return: URL of the uploaded image
+    """
+    try:
+        # API endpoint for ImgBB
+        url = "https://api.imgbb.com/1/upload"
+        
+        # Open the image in binary mode
+        with open(image_path, "rb") as image_file:
+            # Send POST request to upload the image
+            response = requests.post(
+                url,
+                data={"key": api_key},
+                files={"image": image_file}
+            )
+        
+        # Check if the request was successful
+        if response.status_code == 200:
+            data = response.json()
+            print(f'Uploaded to {data["data"]["url"]}')
+            return data["data"]["url"]
+        else:
+            raise Exception(f"Error uploading image: {response.status_code}, {response.text}")
+    except Exception as e:
+        return str(e)
+
+# # Replace with your local image path and ImgBB API key
+# image_path = "fridge.JPG"  # Replace this with your local image path
+# api_key = "0e7fb6d183b8db925812dee230f71079"         # Get your API key from https://api.imgbb.com/
+
+# uploaded_url = upload_image_to_imgbb(image_path, api_key)
+# print(f"Uploaded image URL: {uploaded_url}")

main.py

@@ -0,0 +1,333 @@
+from fastapi import FastAPI, File, UploadFile, Response, HTTPException
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from PIL import Image
+import io
+import requests
+import sqlite3
+from pydantic import BaseModel, EmailStr
+from typing import List, Optional
+
+
+from pathlib import Path
+from model import YOLOModel
+import shutil
+
+from openpyxl import Workbook
+from openpyxl.drawing.image import Image as ExcelImage
+from openpyxl.styles import Alignment
+import os 
+
+yolo = YOLOModel()
+
+UPLOAD_FOLDER = Path("./uploads")
+UPLOAD_FOLDER.mkdir(exist_ok=True)
+
+app = FastAPI()
+
+cropped_images_dir = "cropped_images"
+
+# Initialize SQLite database
+def init_db():
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            firstName TEXT NOT NULL,
+            lastName TEXT NOT NULL,
+            country TEXT,
+            number TEXT,  -- Phone number stored as TEXT to allow various formats
+            email TEXT UNIQUE NOT NULL,  -- Email should be unique and non-null
+            password TEXT NOT NULL  -- Password will be stored as a string (hashed ideally)
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+init_db()
+
+class UserSignup(BaseModel):
+    firstName: str
+    lastName: str
+    country: str 
+    number: str 
+    email: EmailStr
+    password: str
+
+class UserLogin(BaseModel):
+    email: str
+    password: str
+
+@app.post("/signup")
+async def signup(user_data: UserSignup):
+    try:
+        conn = sqlite3.connect('users.db')
+        c = conn.cursor()
+        
+        # Check if user already exists
+        c.execute("SELECT * FROM users WHERE email = ?", (user_data.email,))
+        if c.fetchone():
+            raise HTTPException(status_code=400, detail="Email already registered")
+        
+        # Insert new user
+        c.execute("""
+            INSERT INTO users (firstName, lastName, country, number, email, password) 
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (user_data.firstName, user_data.lastName, user_data.country, user_data.number, user_data.email, user_data.password))
+        
+        conn.commit()
+        conn.close()
+        
+        return {"message": "User registered successfully", "email": user_data.email}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/login")
+async def login(user_data: UserLogin):
+    try:
+        conn = sqlite3.connect('users.db')
+        c = conn.cursor()
+        
+        # Find user
+        c.execute("SELECT * FROM users WHERE email = ? AND password = ?", 
+                  (user_data.email, user_data.password))
+        user = c.fetchone()
+        
+        conn.close()
+        
+        if not user:
+            raise HTTPException(status_code=401, detail="Invalid credentials")
+        
+        return {
+            "message": "Login successful", 
+            "user": {
+                "firstName": user[1],
+                "lastName": user[2],
+                "email": user[3]
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+
+@app.post("/upload")
+async def upload_image(image: UploadFile = File(...)):
+    # print(f'\n\t\tUPLOADED!!!!')
+    try:
+        file_path = UPLOAD_FOLDER / image.filename
+        with file_path.open("wb") as buffer:
+            shutil.copyfileobj(image.file, buffer)
+        # print(f'Starting to pass into model, {file_path}')
+        # Perform YOLO inference
+        predictions = yolo.predict(str(file_path))
+        print(f'\n\n\n{predictions}\n\n\ \n\t\t\t\tare predictions')
+        # Clean up uploaded file
+        file_path.unlink()  # Remove file after processing
+        return JSONResponse(content={"items": predictions})
+    
+
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
+
+@app.get("/download_cropped_image/{image_idx}")
+def download_cropped_image(image_idx: int):
+    cropped_image_path = cropped_images_dir / f"crop_{image_idx}.jpg"
+    if cropped_image_path.exists():
+        return FileResponse(cropped_image_path, media_type="image/jpeg")
+    return JSONResponse(content={"error": "Cropped image not found"}, status_code=404)
+
+
+def cleanup_images(directory: str):
+    """Remove all images in the directory."""
+    for file in Path(directory).glob("*"):
+        file.unlink()
+'''
+
+@app.post("/generate-excel/")
+async def generate_excel(predictions: list):
+    # Create an Excel workbook
+    workbook = Workbook()
+    sheet = workbook.active
+    sheet.title = "Predictions"
+
+    # Add headers
+    headers = ["Category", "Confidence", "Predicted Brand", "Price", "Details", "Detected Text", "Image"]
+    sheet.append(headers)
+
+    for idx, prediction in enumerate(predictions):
+        # Extract details from the prediction
+        category = prediction["category"]
+        confidence = prediction["confidence"]
+        predicted_brand = prediction["predicted_brand"]
+        price = prediction["price"]
+        details = prediction["details"]
+        detected_text = prediction["detected_text"]
+        cropped_image_path = prediction["image_path"]
+
+        # Append data row
+        sheet.append([category, confidence, predicted_brand, price, details, detected_text])
+
+        # Add the image to the Excel file (if it exists)
+        if os.path.exists(cropped_image_path):
+            img = ExcelImage(cropped_image_path)
+            img.width, img.height = 50, 50  # Resize image to fit into the cell
+            sheet.add_image(img, f"G{idx + 2}")  # Place in the "Image" column
+
+    excel_file_path = "predictions_with_images.xlsx"
+    workbook.save(excel_file_path)
+
+    # Cleanup after saving
+    cleanup_images(cropped_images_dir)
+
+    # Serve the Excel file as a response
+    return FileResponse(
+        excel_file_path,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        filename="predictions_with_images.xlsx"
+    )
+
+'''
+
+# Define the Prediction model
+class Prediction(BaseModel):
+    category: Optional[str]
+    confidence: Optional[float]
+    predicted_brand: Optional[str]
+    price: Optional[str]
+    details: Optional[str]
+    detected_text: Optional[str]
+    image_url: Optional[str]
+    image_path: Optional[str]
+    
+
+@app.post("/generate-excel/")
+async def generate_excel(predictions: List[Prediction]):
+    print('Generate excel called')
+
+    # Create an Excel workbook
+    workbook = Workbook()
+    sheet = workbook.active
+    sheet.title = "Predictions"
+
+    # Add headers
+    headers = ["Category", "Confidence", "Predicted Brand", "Price", "Image URL", "Details", "Detected Text", ]
+    sheet.append(headers)
+
+    # Set header style and alignment
+    for cell in sheet[1]:
+        cell.alignment = Alignment(horizontal="center", vertical="center", wrap_text=True)
+    sheet.row_dimensions[1].height = 30  # Adjust header row height
+
+    # Set column widths based on data type
+    column_widths = {
+        "A": 20,  # Category
+        "B": 15,  # Confidence
+        "C": 40,  # Predicted Brand
+        "D": 15,  # Price
+        "E": 50,  # Image URL
+        "F": 30,  # Details 
+        "G": 30   # Detected Text
+    }
+    for col, width in column_widths.items():
+        sheet.column_dimensions[col].width = width
+
+    # Add prediction rows
+    for idx, prediction in enumerate(predictions):
+        row_index = idx + 2  # Start from the second row
+
+        # Add data to the row
+        sheet.append([
+            prediction.category,
+            prediction.confidence,
+            prediction.predicted_brand,
+            prediction.price,
+            prediction.image_url,
+            prediction.details,
+            prediction.detected_text,
+            
+        ])
+
+        # Adjust row height for multiline text
+        sheet.row_dimensions[row_index].height = 180  # Default height for rows
+
+        # Wrap text in all cells of the row
+        for col_idx in range(1, 8):  # Columns A to G
+            cell = sheet.cell(row=row_index, column=col_idx)
+            cell.alignment = Alignment(wrap_text=True, vertical="top")
+
+        # Add image if the path exists
+        if os.path.exists(prediction.image_path):
+            img = ExcelImage(prediction.image_path)
+            img.width, img.height = 160, 160  # Resize image to fit into the cell
+            img_cell = f"G{row_index}"  # Image column
+            sheet.add_image(img, img_cell)
+
+    # Save the Excel file
+    excel_file_path = "predictions_with_images.xlsx"
+    workbook.save(excel_file_path)
+
+    # Serve the Excel file as a response
+    return FileResponse(
+        excel_file_path,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        filename="predictions_with_images.xlsx"
+    )
+'''
+
+@app.post("/generate-excel/")
+async def generate_excel(predictions: list):
+    print('Generate excel called')
+    # Create an Excel workbook
+    workbook = Workbook()
+    sheet = workbook.active
+    sheet.title = "Predictions"
+
+    # Add headers
+    headers = ["Category", "Confidence", "Predicted Brand", "Price", "Details", "Detected Text", "Image URL"]
+    sheet.append(headers)
+
+    # Format the header row
+    for cell in sheet[1]:
+        cell.alignment = Alignment(horizontal="center", vertical="center")
+
+    for idx, prediction in enumerate(predictions):
+        # Extract details from the prediction
+        category = prediction["category"]
+        confidence = prediction["confidence"]
+        predicted_brand = prediction["predicted_brand"]
+        price = prediction["price"]
+        details = prediction["details"]
+        detected_text = prediction["detected_text"]
+        image_url = prediction["image_url"]  # URL to the image
+        cropped_image_path = prediction["image_path"]  # Path to local image file for Excel embedding
+
+        # Append data row
+        sheet.append([category, confidence, predicted_brand, price, details, detected_text, image_url])
+
+        # If the image path exists, add the image to the Excel file
+        if os.path.exists(cropped_image_path):
+            img = ExcelImage(cropped_image_path)
+            img.width, img.height = 50, 50  # Resize image to fit into the cell
+            sheet.add_image(img, f"G{idx + 2}")  # Place in the "Image" column
+
+    excel_file_path = "predictions_with_images.xlsx"
+    workbook.save(excel_file_path)
+
+    # Serve the Excel file as a response
+    return FileResponse(
+        excel_file_path,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        filename="predictions_with_images.xlsx"
+    )
+'''
+
+# code to accept the localhost to get images from
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://192.168.56.1:3000", "http://192.168.56.1:3001", "http://localhost:3000"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)

main2.py

@@ -0,0 +1,188 @@
+from fastapi import FastAPI, File, UploadFile, Response, HTTPException
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+from PIL import Image
+import io
+
+import sqlite3
+from pydantic import BaseModel, EmailStr
+
+from pathlib import Path
+from model import YOLOModel
+import shutil
+
+from openpyxl import Workbook
+from openpyxl.drawing.image import Image as ExcelImage
+import os 
+
+yolo = YOLOModel()
+
+UPLOAD_FOLDER = Path("./uploads")
+UPLOAD_FOLDER.mkdir(exist_ok=True)
+
+app = FastAPI()
+
+cropped_images_dir = "cropped_images"
+
+# Initialize SQLite database
+def init_db():
+    conn = sqlite3.connect('users.db')
+    c = conn.cursor()
+    c.execute('''
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            firstName TEXT NOT NULL,
+            lastName TEXT NOT NULL,
+            country TEXT,
+            number TEXT,  -- Phone number stored as TEXT to allow various formats
+            email TEXT UNIQUE NOT NULL,  -- Email should be unique and non-null
+            password TEXT NOT NULL  -- Password will be stored as a string (hashed ideally)
+        )
+    ''')
+    conn.commit()
+    conn.close()
+
+init_db()
+
+class UserSignup(BaseModel):
+    firstName: str
+    lastName: str
+    country: str 
+    number: str 
+    email: EmailStr
+    password: str
+
+class UserLogin(BaseModel):
+    email: str
+    password: str
+
+@app.post("/signup")
+async def signup(user_data: UserSignup):
+    try:
+        conn = sqlite3.connect('users.db')
+        c = conn.cursor()
+        
+        # Check if user already exists
+        c.execute("SELECT * FROM users WHERE email = ?", (user_data.email,))
+        if c.fetchone():
+            raise HTTPException(status_code=400, detail="Email already registered")
+        
+        # Insert new user
+        c.execute("""
+            INSERT INTO users (firstName, lastName, country, number, email, password) 
+            VALUES (?, ?, ?, ?, ?, ?)
+        """, (user_data.firstName, user_data.lastName, user_data.country, user_data.number, user_data.email, user_data.password))
+        
+        conn.commit()
+        conn.close()
+        
+        return {"message": "User registered successfully", "email": user_data.email}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/login")
+async def login(user_data: UserLogin):
+    try:
+        conn = sqlite3.connect('users.db')
+        c = conn.cursor()
+        
+        # Find user
+        c.execute("SELECT * FROM users WHERE email = ? AND password = ?", 
+                  (user_data.email, user_data.password))
+        user = c.fetchone()
+        
+        conn.close()
+        
+        if not user:
+            raise HTTPException(status_code=401, detail="Invalid credentials")
+        
+        return {
+            "message": "Login successful", 
+            "user": {
+                "firstName": user[1],
+                "lastName": user[2],
+                "email": user[3]
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+
+@app.post("/upload")
+async def upload_image(image: UploadFile = File(...)):
+    # print(f'\n\t\tUPLOADED!!!!')
+    try:
+        file_path = UPLOAD_FOLDER / image.filename
+        with file_path.open("wb") as buffer:
+            shutil.copyfileobj(image.file, buffer)
+        # print(f'Starting to pass into model, {file_path}')
+        # Perform YOLO inference
+        predictions = yolo.predict(str(file_path))
+        print(f'\n\n\n{predictions}\n\n\ \n\t\t\t\tare predictions')
+        # Clean up uploaded file
+        file_path.unlink()  # Remove file after processing
+        return JSONResponse(content={"items": predictions})
+    
+
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
+
+def cleanup_images(directory: str):
+    """Remove all images in the directory."""
+    for file in Path(directory).glob("*"):
+        file.unlink()
+
+
+@app.post("/generate-excel/")
+async def generate_excel(predictions: list):
+    # Create an Excel workbook
+    workbook = Workbook()
+    sheet = workbook.active
+    sheet.title = "Predictions"
+
+    # Add headers
+    headers = ["Category", "Confidence", "Predicted Brand", "Price", "Details", "Detected Text", "Image"]
+    sheet.append(headers)
+
+    for idx, prediction in enumerate(predictions):
+        # Extract details from the prediction
+        category = prediction["category"]
+        confidence = prediction["confidence"]
+        predicted_brand = prediction["predicted_brand"]
+        price = prediction["price"]
+        details = prediction["details"]
+        detected_text = prediction["detected_text"]
+        cropped_image_path = prediction["image_path"]
+
+        # Append data row
+        sheet.append([category, confidence, predicted_brand, price, details, detected_text])
+
+        # Add the image to the Excel file (if it exists)
+        if os.path.exists(cropped_image_path):
+            img = ExcelImage(cropped_image_path)
+            img.width, img.height = 50, 50  # Resize image to fit into the cell
+            sheet.add_image(img, f"G{idx + 2}")  # Place in the "Image" column
+
+    excel_file_path = "predictions_with_images.xlsx"
+    workbook.save(excel_file_path)
+
+    # Cleanup after saving
+    cleanup_images(cropped_images_dir)
+
+    # Serve the Excel file as a response
+    return FileResponse(
+        excel_file_path,
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        filename="predictions_with_images.xlsx"
+    )
+
+
+# code to accept the localhost to get images from
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://192.168.56.1:3000", "http://192.168.56.1:3001", "http://localhost:3000"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)

model.py

@@ -0,0 +1,149 @@
+import torch
+from pathlib import Path
+from transformers import CLIPProcessor, CLIPModel
+from PIL import Image, ImageDraw
+import pytesseract
+import requests
+import os 
+from llm import inference, upload_image
+from fastapi.responses import FileResponse, JSONResponse
+
+import re
+
+from io import BytesIO
+
+cropped_images_dir = "cropped_images"
+os.makedirs(cropped_images_dir, exist_ok=True)
+
+# Load YOLO model
+class YOLOModel:
+    def __init__(self, model_path="yolov5s.pt"):
+        """
+        Initialize the YOLO model. Downloads YOLOv5 pretrained model if not available.
+        """
+        torch.hub._validate_not_a_forked_repo=lambda a,b,c: True
+        self.model = torch.hub.load("ultralytics/yolov5", "custom", path=model_path, force_reload=True)
+
+
+    def predict_clip(self, image, brand_names):
+        """
+        Predict the most probable brand using CLIP.
+        """
+        inputs = self.clip_processor(
+            text=brand_names,
+            images=image,
+            return_tensors="pt",
+            padding=True
+        )
+        # print(f'Inputs to clip processor:{inputs}')
+        outputs = self.clip_model(**inputs)
+        logits_per_image = outputs.logits_per_image
+        probs = logits_per_image.softmax(dim=1)  # Convert logits to probabilities
+        best_idx = probs.argmax().item()
+        return brand_names[best_idx], probs[0, best_idx].item()
+
+
+    def predict_text(self, image):
+        grayscale = image.convert('L')
+        text = pytesseract.image_to_string(grayscale)
+        return text.strip()
+
+
+    def predict(self, image_path):
+        """
+        Run YOLO inference on an image.
+
+        :param image_path: Path to the input image
+        :return: List of predictions with labels and bounding boxes
+        """
+        results = self.model(image_path)
+        image = Image.open(image_path).convert("RGB")
+        draw = ImageDraw.Draw(image)
+        predictions = results.pandas().xyxy[0]  # Get predictions as pandas DataFrame
+        print(f'YOLO predictions:\n\n{predictions}')
+        
+        
+        output = []
+        file_responses = []
+        
+        
+        for idx, row in predictions.iterrows():
+            category = row['name']
+            confidence = row['confidence']
+            bbox = [row["xmin"], row["ymin"], row["xmax"], row["ymax"]]
+
+            # Crop the detected region
+            cropped_image = image.crop((bbox[0], bbox[1], bbox[2], bbox[3]))
+            cropped_image_path = os.path.join(cropped_images_dir, f"crop_{idx}.jpg")
+            cropped_image.save(cropped_image_path, "JPEG")
+
+            # uploading to cloud for getting URL to pass into LLM
+            print(f'Uploading now to image url')
+            image_url = upload_image.upload_image_to_imgbb(cropped_image_path)
+            print(f'Image URL received as{image_url}')
+            # inferencing llm for possible brands
+            result_llms = inference.get_name(image_url, category)
+
+            detected_text = self.predict_text(cropped_image)
+            print(f'Details:{detected_text}')
+            print(f'Predicted brand: {result_llms["model"]}')
+            # Draw bounding box and label on the image
+            draw.rectangle(bbox, outline="red", width=3)
+            draw.text(
+                (bbox[0], bbox[1] - 10),
+                f'{result_llms["brand"]})',
+                fill="red"
+            )
+
+            cropped_image_io = BytesIO()
+            cropped_image.save(cropped_image_io, format="JPEG")
+            cropped_image_io.seek(0)
+
+            # Append result
+            output.append({
+                "category": category,
+                "bbox": bbox,
+                "confidence": confidence,
+                "category_llm":result_llms["brand"],
+                "predicted_brand": result_llms["model"],
+                # "clip_confidence": clip_confidence,
+                "price":result_llms["price"],
+                "details":result_llms["description"],
+                "detected_text":detected_text,
+                "image_path":cropped_image_path,
+                "image_url":image_url,
+            })
+
+            # file_responses.append(f"/download_cropped_image/{idx}")
+
+            valid_indices = set(range(len(predictions)))
+
+            # Iterate over all files in the directory
+            for filename in os.listdir(cropped_images_dir):
+                # Check if the filename matches the pattern for cropped images
+                if filename.startswith("crop_") and filename.endswith(".jpg"):
+                    # Extract the index from the filename
+                    try:
+                        file_idx = int(filename.split("_")[1].split(".")[0])
+                        if file_idx not in valid_indices:
+                            # Delete the file if its index is not valid
+                            file_path = os.path.join(cropped_images_dir, filename)
+                            os.remove(file_path)
+                            print(f"Deleted excess file: {filename}")
+                    except ValueError:
+                        # Skip files that don't match the pattern
+                        continue
+
+        return output
+    #     return JSONResponse(
+    #     content={
+    #         "metadata": results,
+    #         "cropped_image_urls": [
+    #             f"/download_cropped_image/{idx}" for idx in range(len(file_responses))
+    #         ],
+    #     }
+    # )
+        # return {"metadata": results, "cropped_image_urls": file_responses}
+
+
+