Files deleted

api/product_routes.py

@@ -1,7 +1,6 @@
 from fastapi import APIRouter, File, UploadFile, HTTPException, Form
 from utils.image_processing import read_image_file, process_product_image
-# from product_detector.detector import ObjectDetector  # Temporarily disabled - model corrupted
-from product_detector.mock_detector import MockObjectDetector as ObjectDetector
+from product_detector.detector import ObjectDetector
 from config.settings import MODEL_ONNX_PATH, CLASS_NAMES, INPUT_SIZE
 from utils.image_processing import process_and_store_product_image
 

db/similarity_repository.py

@@ -234,39 +234,6 @@ class SimilarityRepository:
             return self._get_sample_promo_products()
     
    
-    def update_product_image(self, product_id: str, image_url: str) -> bool:
-        """
-        Update product image in database
-        
-        Args:
-            product_id: Product ID to update
-            image_url: New image URL
-            
-        Returns:
-            True if successful, False otherwise
-        """
-        if not self.supabase:
-            logger.error("❌ No Supabase connection")
-            return False
-        
-        try:
-            logger.info(f"📊 Updating product {product_id} with image URL")
-            
-            result = self.supabase.table('products').update({
-                'product_image': image_url
-            }).eq('product_id', product_id).execute()
-            
-            if result.data:
-                logger.info(f"✅ Updated product {product_id} with image")
-                return True
-            else:
-                logger.error(f"❌ Failed to update product {product_id}")
-                return False
-                
-        except Exception as e:
-            logger.error(f"❌ Database update error for product {product_id}: {e}")
-            return False
-    
     def get_products_without_images(self, limit: Optional[int] = None) -> List[Dict[str, Any]]:
         """
         Get products that don't have images

product_detector/__init__.py

@@ -0,0 +1 @@
+# Product detector package

product_detector/mock_detector.py

@@ -1,33 +0,0 @@
-import numpy as np
-from typing import List, Dict
-import warnings
-
-class MockObjectDetector:
-    """
-    Mock Object Detector to temporarily replace the broken ONNX model
-    Returns dummy detection results to keep the server running
-    """
-    
-    def __init__(self, model_path: str, class_names: List[str], input_size: int = 640):
-        self.class_names = class_names
-        self.input_size = input_size
-        print(f"🔧 Mock detector initialized - model file was corrupted")
-        print(f"📝 Available classes: {class_names}")
-        
-    def predict(self, image: np.ndarray) -> List[Dict]:
-        """
-        Mock prediction method - returns sample detections
-        Replace this with real detector once model is fixed
-        """
-        # Return mock detection results
-        mock_detections = [
-            {
-                "class": "product" if len(self.class_names) > 0 else "unknown",
-                "confidence": 0.85,
-                "bbox": [100, 100, 300, 250],  # x1, y1, x2, y2
-                "bbox_normalized": [0.3, 0.3, 0.4, 0.5]  # center_x, center_y, width, height (normalized)
-            }
-        ]
-        
-        print(f"🔍 Mock detection completed - found {len(mock_detections)} objects")
-        return mock_detections

similarity_engine/enhanced_image_processor.py

@@ -1,531 +0,0 @@
-"""
-Enhanced Image Processor - Multiple Sources & Flexible Processing
-Supports promo products, manual uploads, URL sources, Google Images, and more
-"""
-
-import os
-import logging
-import requests
-import time
-from typing import List, Dict, Any, Optional, Tuple
-import sys
-import os
-
-# Add parent directory to path
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from similarity_core import calculate_similarity, calculate_confidence
-from db.similarity_repository import get_similarity_repository
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class EnhancedImageProcessor:
-    """Enhanced image processor with multiple sources and flexible options"""
-    
-    def __init__(self):
-        """Initialize the image processor"""
-        self.repository = get_similarity_repository()
-        self.processing_stats = {
-            'total_processed': 0,
-            'successful': 0,
-            'failed': 0,
-            'skipped': 0
-        }
-    
-    def find_high_similarity_matches(
-        self, 
-        source_products: List[Dict], 
-        target_products: List[Dict], 
-        threshold: float = 0.95,
-        source_type: str = "promo"
-    ) -> List[Dict[str, Any]]:
-        """
-        Find high similarity matches between source and target products
-        
-        Args:
-            source_products: Products with images (promo, manual, etc.)
-            target_products: Database products to match against
-            threshold: Similarity threshold
-            source_type: Type of source ("promo", "manual", "google", etc.)
-            
-        Returns:
-            List of high similarity matches
-        """
-        logger.info(f"🔍 Finding high similarity matches for {source_type} images")
-        logger.info(f"📊 Source products: {len(source_products)}")
-        logger.info(f"📊 Target products: {len(target_products)}")
-        logger.info(f"🎯 Similarity threshold: {threshold}")
-        
-        matches = []
-        
-        for i, source_product in enumerate(source_products):
-            source_name = source_product.get('name', '').strip()
-            if not source_name:
-                continue
-            
-            logger.info(f"📊 Analyzing {source_type} product {i+1}/{len(source_products)}: {source_name[:50]}...")
-            
-            for target_product in target_products:
-                target_name = target_product.get('product_name', '').strip()
-                if not target_name:
-                    continue
-                
-                similarity = calculate_similarity(source_name, target_name)
-                
-                if similarity >= threshold:
-                    confidence = calculate_confidence(similarity, source_name, target_name)
-                    
-                    match = {
-                        'source_id': source_product.get('id'),
-                        'source_name': source_name,
-                        'source_type': source_type,
-                        'target_product_id': target_product.get('product_id'),
-                        'target_product_name': target_name,
-                        'similarity': round(similarity, 3),
-                        'confidence': round(confidence, 3),
-                        'has_current_image': bool(target_product.get('product_image')),
-                        'source_image_info': self._extract_image_info(source_product, source_type)
-                    }
-                    
-                    matches.append(match)
-                    logger.info(f"  🔍 HIGH MATCH: {source_name} ↔ {target_name} ({similarity:.3f})")
-                    break
-        
-        logger.info(f"✅ Found {len(matches)} high similarity matches")
-        return matches
-    
-    def _extract_image_info(self, product: Dict, source_type: str) -> Dict[str, Any]:
-        """Extract image information based on source type"""
-        if source_type == "promo":
-            picture_id = product.get('picture_id')
-            return {
-                'picture_id': picture_id,
-                'image_url': f"https://backend.360promo.hr/contents/products/{picture_id}.jpg" if picture_id else None,
-                'store': product.get('store'),
-                'promo_price': product.get('promo_price'),
-                'regular_price': product.get('regular_price')
-            }
-        elif source_type == "manual":
-            return {
-                'image_url': product.get('image_url'),
-                'original_filename': product.get('filename'),
-                'uploaded_by': product.get('uploaded_by')
-            }
-        elif source_type == "google":
-            return {
-                'image_url': product.get('image_url'),
-                'source_page': product.get('source_page'),
-                'search_query': product.get('search_query')
-            }
-        elif source_type == "url":
-            return {
-                'image_url': product.get('image_url'),
-                'source_domain': product.get('source_domain')
-            }
-        else:
-            return {
-                'image_url': product.get('image_url', product.get('picture_url'))
-            }
-    
-    def check_image_availability(self, image_url: str) -> bool:
-        """Check if image URL is accessible"""
-        try:
-            response = requests.head(image_url, timeout=10)
-            return response.status_code == 200
-        except Exception as e:
-            logger.warning(f"⚠️ Image not accessible: {image_url} - {e}")
-            return False
-    
-    def process_image_from_url(
-        self, 
-        image_url: str, 
-        product_id: str,
-        processing_options: Dict[str, Any] = None
-    ) -> Optional[str]:
-        """
-        Download and process image from URL
-        
-        Args:
-            image_url: Source image URL
-            product_id: Target product ID
-            processing_options: Processing configuration
-            
-        Returns:
-            Processed image URL or None if failed
-        """
-        if processing_options is None:
-            processing_options = {
-                'remove_background': True,
-                'upscale_factor': 2,
-                'target_format': 'webp',
-                'quality': 85
-            }
-        
-        try:
-            logger.info(f"📥 Downloading image from: {image_url}")
-            
-            # Download image
-            response = requests.get(image_url, timeout=30)
-            if response.status_code != 200:
-                logger.error(f"❌ Failed to download: HTTP {response.status_code}")
-                return None
-            
-            logger.info("✅ Image downloaded successfully")
-            
-            # Try to process via backend endpoint
-            processed_url = self._process_via_backend(
-                response.content, 
-                product_id, 
-                processing_options
-            )
-            
-            if processed_url:
-                return processed_url
-            
-            # If processing fails, return original URL
-            logger.warning("⚠️ Processing failed, using original URL")
-            return image_url
-            
-        except Exception as e:
-            logger.error(f"❌ Error processing image from URL: {e}")
-            return None
-    
-    def _process_via_backend(
-        self, 
-        image_content: bytes, 
-        product_id: str, 
-        options: Dict[str, Any]
-    ) -> Optional[str]:
-        """Process image via backend endpoint"""
-        try:
-            # Get backend endpoint
-            endpoint = os.getenv('IMAGE_PROCESS_ENDPOINT', 'http://localhost:7860/products/process-product-image')
-            
-            files = {'file': ('image.jpg', image_content, 'image/jpeg')}
-            data = {
-                'remove_bg': str(options.get('remove_background', True)).lower(),
-                'upscale': str(options.get('upscale_factor', 2) > 1).lower(),
-                'scale_factor': str(options.get('upscale_factor', 2)),
-                'process_order': 'remove_first',
-                'product_id': product_id
-            }
-            
-            response = requests.post(endpoint, files=files, data=data, timeout=60)
-            
-            if response.status_code == 200:
-                result = response.json()
-                if result.get('status') == 'success':
-                    logger.info("✅ Image processed successfully via backend")
-                    return result.get('image_url')
-            
-            logger.warning(f"⚠️ Backend processing failed: {response.status_code}")
-            return None
-            
-        except Exception as e:
-            logger.warning(f"⚠️ Backend processing unavailable: {e}")
-            return None
-    
-    def process_promo_images(
-        self, 
-        similarity_threshold: float = 0.95,
-        skip_existing: bool = True,
-        max_products: Optional[int] = None
-    ) -> Dict[str, int]:
-        """
-        Process images from promotional products
-        
-        Args:
-            similarity_threshold: Minimum similarity for processing
-            skip_existing: Skip products that already have images
-            max_products: Maximum products to process
-            
-        Returns:
-            Processing statistics
-        """
-        logger.info("🏷️ Starting promo image processing...")
-        
-        # Load promo products with images
-        promo_products = self.repository.load_promo_products(with_images_only=True)
-        if not promo_products:
-            logger.error("❌ No promo products with images found")
-            return self._get_empty_stats()
-        
-        # Load target products
-        if skip_existing:
-            target_products = self.repository.get_products_without_images(max_products)
-        else:
-            all_products = self.repository.load_all_products()
-            target_products = all_products[:max_products] if max_products else all_products
-        
-        if not target_products:
-            logger.error("❌ No target products found")
-            return self._get_empty_stats()
-        
-        # Find matches
-        matches = self.find_high_similarity_matches(
-            promo_products, 
-            target_products, 
-            similarity_threshold,
-            "promo"
-        )
-        
-        return self._process_matches(matches, skip_existing)
-    
-    def process_manual_upload(
-        self, 
-        image_file: bytes, 
-        filename: str,
-        product_id: str,
-        processing_options: Dict[str, Any] = None
-    ) -> bool:
-        """
-        Process manually uploaded image
-        
-        Args:
-            image_file: Image file content
-            filename: Original filename
-            product_id: Target product ID
-            processing_options: Processing configuration
-            
-        Returns:
-            True if successful
-        """
-        logger.info(f"📤 Processing manual upload for product {product_id}")
-        
-        try:
-            # Process image
-            processed_url = self._process_via_backend(
-                image_file, 
-                product_id, 
-                processing_options or {}
-            )
-            
-            if not processed_url:
-                logger.error("❌ Failed to process uploaded image")
-                return False
-            
-            # Update database
-            success = self.repository.update_product_image(product_id, processed_url)
-            
-            if success:
-                # Save metadata
-                self.repository.save_image_metadata(product_id, {
-                    'source_type': 'manual',
-                    'original_filename': filename,
-                    'processed_url': processed_url,
-                    'upload_time': time.time()
-                })
-                
-                logger.info(f"✅ Successfully attached manual upload to product {product_id}")
-                return True
-            
-            return False
-            
-        except Exception as e:
-            logger.error(f"❌ Error processing manual upload: {e}")
-            return False
-    
-    def process_from_url_list(
-        self, 
-        url_mappings: List[Dict[str, str]],
-        processing_options: Dict[str, Any] = None
-    ) -> Dict[str, int]:
-        """
-        Process images from a list of URL mappings
-        
-        Args:
-            url_mappings: List of {'product_id': 'xxx', 'image_url': 'xxx'} mappings
-            processing_options: Processing configuration
-            
-        Returns:
-            Processing statistics
-        """
-        logger.info(f"🌐 Processing {len(url_mappings)} URL mappings...")
-        
-        stats = self._get_empty_stats()
-        stats['total_processed'] = len(url_mappings)
-        
-        for mapping in url_mappings:
-            product_id = mapping.get('product_id')
-            image_url = mapping.get('image_url')
-            
-            if not product_id or not image_url:
-                stats['failed'] += 1
-                continue
-            
-            logger.info(f"📊 Processing URL for product {product_id}")
-            
-            # Check availability
-            if not self.check_image_availability(image_url):
-                stats['failed'] += 1
-                continue
-            
-            # Process image
-            processed_url = self.process_image_from_url(
-                image_url, 
-                product_id, 
-                processing_options
-            )
-            
-            if processed_url:
-                # Update database
-                if self.repository.update_product_image(product_id, processed_url):
-                    stats['successful'] += 1
-                    
-                    # Save metadata
-                    self.repository.save_image_metadata(product_id, {
-                        'source_type': 'url',
-                        'source_url': image_url,
-                        'processed_url': processed_url,
-                        'processing_time': time.time()
-                    })
-                else:
-                    stats['failed'] += 1
-            else:
-                stats['failed'] += 1
-        
-        logger.info(f"✅ URL processing complete: {stats['successful']}/{stats['total_processed']} successful")
-        return stats
-    
-    def search_and_attach_google_images(
-        self, 
-        product_id: str, 
-        search_query: str,
-        max_results: int = 3,
-        require_approval: bool = True
-    ) -> List[Dict[str, Any]]:
-        """
-        Search Google Images and find potential matches
-        
-        Args:
-            product_id: Target product ID
-            search_query: Search query for Google Images
-            max_results: Maximum results to return
-            require_approval: Whether manual approval is required
-            
-        Returns:
-            List of potential image matches
-        """
-        logger.info(f"🔍 Google Image search for product {product_id}: '{search_query}'")
-        
-        # TODO: Implement Google Images API integration
-        # For now, return mock results
-        mock_results = [
-            {
-                'image_url': f'https://example.com/mock-image-1.jpg',
-                'thumbnail_url': f'https://example.com/mock-thumb-1.jpg',
-                'source_page': f'https://example.com/product-page-1',
-                'title': f'Mock result for {search_query}',
-                'confidence': 0.85
-            }
-        ]
-        
-        logger.info(f"🔍 Found {len(mock_results)} potential Google Image matches")
-        logger.warning("⚠️ Google Images integration not yet implemented - returning mock data")
-        
-        return mock_results
-    
-    def _process_matches(self, matches: List[Dict], skip_existing: bool = True) -> Dict[str, int]:
-        """Process similarity matches and attach images"""
-        stats = self._get_empty_stats()
-        stats['total_processed'] = len(matches)
-        
-        if not matches:
-            return stats
-        
-        # Filter existing if needed
-        if skip_existing:
-            to_process = [m for m in matches if not m['has_current_image']]
-            stats['skipped'] = len(matches) - len(to_process)
-            matches = to_process
-        
-        logger.info(f"📊 Processing images for {len(matches)} products...")
-        
-        for match in matches:
-            product_id = match['target_product_id']
-            image_info = match['source_image_info']
-            image_url = image_info.get('image_url')
-            
-            if not image_url:
-                stats['failed'] += 1
-                continue
-            
-            logger.info(f"📊 Processing image for product {product_id}")
-            
-            # Check availability
-            if not self.check_image_availability(image_url):
-                stats['failed'] += 1
-                continue
-            
-            # Process image
-            processed_url = self.process_image_from_url(image_url, product_id)
-            
-            if processed_url and self.repository.update_product_image(product_id, processed_url):
-                stats['successful'] += 1
-                
-                # Save metadata
-                self.repository.save_image_metadata(product_id, {
-                    'source_type': match['source_type'],
-                    'similarity': match['similarity'],
-                    'confidence': match['confidence'],
-                    'source_info': image_info,
-                    'processing_time': time.time()
-                })
-                
-                logger.info(f"✅ Successfully attached image to product {product_id}")
-            else:
-                stats['failed'] += 1
-        
-        return stats
-    
-    def _get_empty_stats(self) -> Dict[str, int]:
-        """Get empty statistics dictionary"""
-        return {
-            'total_processed': 0,
-            'successful': 0,
-            'failed': 0,
-            'skipped': 0,
-            'unavailable': 0
-        }
-    
-    def get_processing_report(self, stats: Dict[str, int]) -> Dict[str, Any]:
-        """Generate processing report"""
-        return {
-            'summary': {
-                'total_processed': stats['total_processed'],
-                'successful': stats['successful'],
-                'failed': stats['failed'],
-                'skipped': stats.get('skipped', 0),
-                'success_rate': (stats['successful'] / max(stats['total_processed'], 1)) * 100
-            },
-            'timestamp': time.time(),
-            'recommendations': self._generate_recommendations(stats)
-        }
-    
-    def _generate_recommendations(self, stats: Dict[str, int]) -> List[str]:
-        """Generate recommendations based on processing stats"""
-        recommendations = []
-        
-        if stats['failed'] > stats['successful']:
-            recommendations.append("High failure rate - check image sources and processing settings")
-        
-        if stats.get('skipped', 0) > 0:
-            recommendations.append(f"{stats['skipped']} products already had images - consider processing all products")
-        
-        if stats['successful'] > 0:
-            recommendations.append(f"Successfully processed {stats['successful']} images - consider similar processing for remaining products")
-        
-        return recommendations
-
-
-# Global processor instance
-_processor = None
-
-def get_image_processor() -> EnhancedImageProcessor:
-    """Get singleton image processor instance"""
-    global _processor
-    if _processor is None:
-        _processor = EnhancedImageProcessor()
-    return _processor