moved function to utils

utils/db_utils.py

@@ -0,0 +1,62 @@
+from sqlalchemy.orm import Session
+from interfaces.ingredientModels import IngredientAnalysisResult
+from interfaces.productModels import ProductCreate
+from db.models import Marker
+from logger_manager import log_info, log_error
+from fastapi import HTTPException
+import os
+from services.product_service import ProductService
+from routers.product import add_target_to_vuforia, UPLOADED_IMAGES_DIR # Assuming add_target_to_vuforia and UPLOADED_IMAGES_DIR are needed and will remain in product.py for now. If they are also moved, the import needs adjustment.
+
+
+def ingredient_db_to_pydantic(db_ingredient):
+    """Convert a database ingredient model to a Pydantic model."""
+    return IngredientAnalysisResult(
+        name=db_ingredient.name,
+        alternate_names=db_ingredient.alternate_names or [],
+        is_found=True,
+        id=db_ingredient.id,
+        safety_rating=db_ingredient.safety_rating or 5,
+        description=db_ingredient.description or "No description available",
+        health_effects=db_ingredient.health_effects or ["Unknown"],
+        details_with_source=[source.data for source in db_ingredient.sources]
+    )
+
+
+async def add_product_to_database(
+    product_id: int,
+    image_names: List[str],
+    db: Session,
+    product_data: Dict[str, Any],
+):
+    """
+    Adds markers for the product, or updates it if it exists.
+    """
+    try:
+        log_info(f"Adding markers to product with ID {product_id} in database")
+        product_service = ProductService(db)
+        product = product_service.get_product_by_id(product_id)
+        if not product:
+            raise Exception(f"Product with ID {product_id} not found")
+
+        # Add or update markers for the product
+        for image_name in image_names:
+            image_path = os.path.join(UPLOADED_IMAGES_DIR, image_name)
+
+            vuforia_id = await add_target_to_vuforia(image_name, image_path)
+            existing_marker = db.query(Marker).filter_by(image_name=image_name, product_id=product.id).first()
+
+            if not existing_marker:
+                marker = Marker(image_name=image_name, vuforia_id=vuforia_id, product_id=product.id)
+                db.add(marker)
+            else:
+                log_info(f"Marker {image_name} already exists for product {product_id}. Updating Vuforia ID.")
+                existing_marker.vuforia_id = vuforia_id
+
+        db.commit()
+        log_info(f"Product markers added/updated successfully in database")
+        return True
+    except Exception as e:
+        db.rollback()
+        log_error(f"Error adding/updating markers for product {product_id} in database: {e}",e)
+        raise HTTPException(status_code=500, detail=f"Error adding/updating markers for product {product_id}: {e}")

utils/external_api_utils.py

@@ -0,0 +1,54 @@
+import requests
+import json
+import os
+from logger_manager import log_info, log_error
+from dotenv import load_dotenv
+
+load_dotenv()
+
+VUFORIA_SERVER_ACCESS_KEY = os.getenv("VUFORIA_SERVER_ACCESS_KEY")
+VUFORIA_SERVER_SECRET_KEY = os.getenv("VUFORIA_SERVER_SECRET_KEY")
+
+def get_vuforia_auth_headers():
+    """
+    Returns the authentication headers for Vuforia API requests.
+    """
+    return {
+        "Authorization": f"VWS {VUFORIA_SERVER_ACCESS_KEY}:{VUFORIA_SERVER_SECRET_KEY}",
+        "Content-Type": "application/json",
+    }
+
+
+async def add_target_to_vuforia(image_name: str, image_path: str) -> str:
+    """
+    Adds a target to the Vuforia database and returns the Vuforia target ID.
+    """
+    log_info(f"Adding target {image_name} to Vuforia")
+
+    try:
+        with open(image_path, "rb") as image_file:
+            image_data = image_file.read()
+
+        url = f"https://vws.vuforia.com/targets"
+
+        headers = get_vuforia_auth_headers()
+        payload = {
+            "name": image_name,
+            "width": 1.0,  # Default width
+            "image": image_data.hex(),  # Convert image data to hex
+            "active_flag": True,
+        }
+
+        response = requests.post(url, headers=headers, json=payload)
+        response_data = json.loads(response.text)
+        if response.status_code == 201:
+            log_info(
+                f"Target {image_name} added successfully with Vuforia ID: {response_data['target_id']}"
+            )
+            return response_data["target_id"]
+        else:
+            log_error(f"Failed to add target {image_name}: {response.text}")
+            raise Exception(f"Failed to add target {image_name}: {response.text}")
+    except Exception as e:
+        log_error(f"Error adding target {image_name}: {e}", e)
+        raise

utils/image_processing.py

@@ -1,19 +0,0 @@
-import cv2
-import pytesseract
-
-def extract_text_from_image(image_path):
-    image = cv2.imread(image_path)
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    gray = cv2.medianBlur(gray, 3)
-    text = pytesseract.image_to_string(gray)
-    return text
-
-def detect_barcode_from_image(image_path):
-    image = cv2.imread(image_path)
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    gray = cv2.medianBlur(gray, 3)
-    detector = cv2.QRCodeDetector()
-    data, bbox, _ = detector.detectAndDecode(gray)
-    if bbox is not None:
-        return data
-    return None

utils/image_processing_utils.py

@@ -0,0 +1,93 @@
+import tensorflow as tf
+import tensorflow_hub as hub
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont, ImageOps
+import requests
+from io import BytesIO
+import os
+
+
+# Load the model from TF Hub
+# Cache the model globally
+detector = hub.load("https://tfhub.dev/google/openimages_v4/ssd/mobilenet_v2/1").signatures['default']
+
+# Classes you care about
+TARGET_CLASSES = set(["Food processor", "Fast food", "Food", "Seafood", "Snack"])
+
+UPLOADED_IMAGES_DIR = "uploaded_images"
+if not os.path.exists(UPLOADED_IMAGES_DIR):
+    os.makedirs(UPLOADED_IMAGES_DIR)
+
+
+def load_image_from_url(url, size=(640, 480)):
+    response = requests.get(url)
+    img = Image.open(BytesIO(response.content)).convert("RGB")
+    img = ImageOps.fit(img, size, Image.Resampling.LANCZOS)
+    return img
+
+
+def run_object_detection(image: Image.Image):
+    image_np = np.array(image)
+    # Convert to tensor without specifying dtype
+    input_tensor = tf.convert_to_tensor(image_np)[tf.newaxis, ...]
+    # Convert to float32 and normalize to [0,1]
+    input_tensor = tf.cast(input_tensor, tf.float32) / 255.0
+    results = detector(input_tensor)
+    results = {k: v.numpy() for k, v in results.items()}
+    return results, image_np
+
+def get_filtered_class_boxes(results):
+    # for same class, keep the one with the highest score
+    # and remove duplicates
+    boxes = []
+    classes = []
+    scores = []
+
+    for i in range(len(results["detection_scores"])):
+        class_name = results["detection_class_entities"][i].decode("utf-8")
+        box = results["detection_boxes"][i]
+        score = results["detection_scores"][i]
+        if class_name in TARGET_CLASSES:
+            if class_name not in classes:
+                boxes.append(box)
+                classes.append(class_name)
+                scores.append(score)
+            else:
+                index = classes.index(class_name)
+                if score > scores[index]:
+                    boxes[index] = box
+                    classes[index] = class_name
+                    scores[index] = score
+    return boxes, classes, scores
+
+
+def crop_and_save(image_np, boxes, class_names, scores, min_score=0.3):
+    cropped_images = []
+    for i in range(len(scores)):
+        if scores[i] > min_score:
+            ymin, xmin, ymax, xmax = boxes[i]
+            im_width, im_height = image_np.shape[1], image_np.shape[0]
+            (left, right, top, bottom) = (xmin * im_width, xmax * im_width,
+                                          ymin * im_height, ymax * im_height)
+            cropped_image = image_np[int(top):int(bottom), int(left):int(right)]
+            cropped_images.append((cropped_image, class_names[i], scores[i]))
+            # Save the cropped image
+            pil_image = Image.fromarray(cropped_image)
+            pil_image.save(os.path.join(UPLOADED_IMAGES_DIR, f"{class_names[i]}_{scores[i]:.2f}.jpg"))
+    return cropped_images
+
+def draw_boxes(image_np, boxes, class_names, scores, min_score=0.3):
+    image_pil = Image.fromarray(image_np)
+    draw = ImageDraw.Draw(image_pil)
+    font = ImageFont.load_default()
+
+    for i in range(len(scores)):
+        label = class_names[i]
+        if label in TARGET_CLASSES and scores[i] > min_score:
+            ymin, xmin, ymax, xmax = boxes[i]
+            im_width, im_height = image_pil.size
+            (left, right, top, bottom) = (xmin * im_width, xmax * im_width,
+                                          ymin * im_height, ymax * im_height)
+            draw.rectangle([left, top, right, bottom], outline="red", width=2)
+            draw.text((left, top), f"{label}: {scores[i]*100:.1f}%", fill="white", font=font)
+    return image_pil

utils/ingredient_utils.py

@@ -0,0 +1,64 @@
+import asyncio
+import os
+from sqlalchemy.orm import Session
+from db.database import SessionLocal
+from db.repositories import IngredientRepository
+from interfaces.ingredientModels import IngredientAnalysisResult
+from services.ingredientFinderAgent import IngredientInfoAgentLangGraph
+from dotenv import load_dotenv
+from langsmith import traceable
+import pytz
+
+# Load environment variables
+load_dotenv()
+
+# Get rate limit from environment variable or use default
+PARALLEL_RATE_LIMIT = int(os.getenv("PARALLEL_RATE_LIMIT", 10))
+
+# Create a semaphore to limit concurrent API calls
+llm_semaphore = asyncio.Semaphore(PARALLEL_RATE_LIMIT)
+
+
+@traceable
+async def process_single_ingredient(ingredient_name: str):
+    """Process a single ingredient asynchronously with rate limiting"""
+    # Create a new DB session for this specific task to avoid conflicts
+    session = SessionLocal()
+
+    try:
+        # Check if ingredient exists in database
+        repo = IngredientRepository(session)
+        db_ingredient = repo.get_ingredient_by_name(ingredient_name)
+
+        if db_ingredient:
+            # Assuming ingredient_db_to_pydantic is now in a utils file, e.g., utils.db_utils
+            from .db_utils import ingredient_db_to_pydantic
+            ingredient_data = ingredient_db_to_pydantic(db_ingredient)
+            return ingredient_data
+        else:
+            # Apply rate limiting for LLM calls only if not in database
+            async with llm_semaphore:
+                # Get from agent if not in database
+                ingredient_finder = IngredientInfoAgentLangGraph()
+
+                ingredient_data = await ingredient_finder.process_ingredient_async(ingredient_name)
+
+                # Save to database for future use
+                repo.create_ingredient(ingredient_data)
+
+                return ingredient_data
+    except Exception as e:
+        # Return a minimal result on error to avoid failing the entire batch
+        return IngredientAnalysisResult(
+            name=ingredient_name,
+            is_found=False,
+            safety_rating=0,
+            description=f"Error during processing: {str(e)}",
+            health_effects=["Error during processing"],
+            allergic_info=[],
+            diet_type="unknown",
+            details_with_source=[]
+        )
+    finally:
+        # Important: Close the session when done
+        session.close()