Upload 21 files

models/parallel_processor.py

@@ -0,0 +1,324 @@
+# models/parallel_processor.py
+
+import multiprocessing as mp
+import concurrent.futures
+import asyncio
+import threading
+from functools import partial
+from typing import Dict, Any, List, Tuple
+from .logging_config import logger
+
+class ParallelProcessor:
+    """Handles parallel processing of property verification analyses"""
+    
+    def __init__(self, max_workers=None):
+        self.max_workers = max_workers or min(mp.cpu_count(), 8)
+        self.thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers)
+        self.process_pool = concurrent.futures.ProcessPoolExecutor(max_workers=min(4, mp.cpu_count()))
+        
+    def __del__(self):
+        self.thread_pool.shutdown(wait=True)
+        self.process_pool.shutdown(wait=True)
+    
+    def process_images_parallel(self, image_files):
+        """Process multiple images in parallel"""
+        try:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(image_files))) as executor:
+                futures = []
+                for img_file in image_files:
+                    future = executor.submit(self._process_single_image, img_file)
+                    futures.append(future)
+                
+                results = []
+                for future in concurrent.futures.as_completed(futures):
+                    try:
+                        result = future.result(timeout=30)
+                        results.append(result)
+                    except Exception as e:
+                        logger.error(f"Error processing image: {str(e)}")
+                        results.append({'error': str(e), 'is_property_related': False})
+                
+                return results
+        except Exception as e:
+            logger.error(f"Error in parallel image processing: {str(e)}")
+            return []
+    
+    def _process_single_image(self, img_file):
+        """Process a single image"""
+        try:
+            from PIL import Image
+            import base64
+            import io
+            from .image_analysis import analyze_image
+            
+            img = Image.open(img_file)
+            buffered = io.BytesIO()
+            img.save(buffered, format="JPEG")
+            img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
+            
+            analysis = analyze_image(img)
+            return {
+                'image_data': img_str,
+                'analysis': analysis
+            }
+        except Exception as e:
+            logger.error(f"Error processing image {img_file.filename}: {str(e)}")
+            return {'error': str(e), 'is_property_related': False}
+    
+    def process_pdfs_parallel(self, pdf_files):
+        """Process multiple PDFs in parallel"""
+        try:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(pdf_files))) as executor:
+                futures = []
+                for pdf_file in pdf_files:
+                    future = executor.submit(self._process_single_pdf, pdf_file)
+                    futures.append(future)
+                
+                results = []
+                for future in concurrent.futures.as_completed(futures):
+                    try:
+                        result = future.result(timeout=60)
+                        results.append(result)
+                    except Exception as e:
+                        logger.error(f"Error processing PDF: {str(e)}")
+                        results.append({'error': str(e)})
+                
+                return results
+        except Exception as e:
+            logger.error(f"Error in parallel PDF processing: {str(e)}")
+            return []
+    
+    def _process_single_pdf(self, pdf_file):
+        """Process a single PDF"""
+        try:
+            from .pdf_analysis import extract_pdf_text, analyze_pdf_content
+            
+            pdf_text = extract_pdf_text(pdf_file)
+            analysis = analyze_pdf_content(pdf_text, {})
+            
+            return {
+                'filename': pdf_file.filename,
+                'text': pdf_text,
+                'analysis': analysis
+            }
+        except Exception as e:
+            logger.error(f"Error processing PDF {pdf_file.filename}: {str(e)}")
+            return {'error': str(e)}
+    
+    async def run_analyses_parallel(self, data, consolidated_text, image_analysis, pdf_analysis):
+        """Run all analyses in parallel using asyncio and thread pools"""
+        try:
+            # Prepare property data for price analysis
+            property_data = self._prepare_property_data(data)
+            price_context = self._create_price_context(data)
+            
+            # Define analysis tasks with their respective functions
+            analysis_tasks = [
+                ('summary', self._run_summary_analysis, data),
+                ('fraud', self._run_fraud_analysis, consolidated_text, data),
+                ('trust', self._run_trust_analysis, consolidated_text, image_analysis, pdf_analysis),
+                ('suggestions', self._run_suggestions_analysis, consolidated_text, data),
+                ('quality', self._run_quality_analysis, data.get('description_translated', '')),
+                ('address', self._run_address_analysis, data),
+                ('cross_validation', self._run_cross_validation_analysis, data),
+                ('location', self._run_location_analysis, data),
+                ('price', self._run_price_analysis, data, price_context, property_data),
+                ('legal', self._run_legal_analysis, data.get('legal_details', '')),
+                ('specs', self._run_specs_analysis, data),
+                ('market', self._run_market_analysis, data)
+            ]
+            
+            # Run tasks in parallel with timeout
+            loop = asyncio.get_event_loop()
+            tasks = []
+            
+            for task_name, func, *args in analysis_tasks:
+                task = loop.run_in_executor(
+                    self.thread_pool, 
+                    func, 
+                    *args
+                )
+                tasks.append((task_name, task))
+            
+            # Wait for all tasks to complete with timeout
+            results = {}
+            for task_name, task in tasks:
+                try:
+                    result = await asyncio.wait_for(task, timeout=120)  # 2 minutes timeout per task
+                    results[task_name] = result
+                except asyncio.TimeoutError:
+                    logger.error(f"Task {task_name} timed out")
+                    results[task_name] = self._get_error_result(f"Task {task_name} timed out")
+                except Exception as e:
+                    logger.error(f"Task {task_name} failed: {str(e)}")
+                    results[task_name] = self._get_error_result(f"Task {task_name} failed: {str(e)}")
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"Error in parallel analyses: {str(e)}")
+            return self._get_all_error_results(str(e))
+    
+    def _prepare_property_data(self, data):
+        """Prepare property data for price analysis"""
+        property_data = {}
+        try:
+            if data.get('sq_ft'):
+                property_data['size'] = float(data['sq_ft'])
+            if data.get('market_value'):
+                property_data['price'] = float(data['market_value'].replace('₹', '').replace(',', ''))
+            if data.get('year_built'):
+                from datetime import datetime
+                current_year = datetime.now().year
+                property_data['property_age'] = current_year - int(data['year_built'])
+        except Exception as e:
+            logger.warning(f"Error preparing property data: {str(e)}")
+        return property_data
+    
+    def _create_price_context(self, data):
+        """Create context text for price analysis"""
+        return f"""
+        Property: {data.get('property_name', '')}
+        Type: {data.get('property_type', '')}
+        Location: {data.get('address', '')}, {data.get('city', '')}, {data.get('state', '')}
+        Size: {data.get('sq_ft', '')} sq ft
+        Market Value: ₹{data.get('market_value', '')}
+        Description: {data.get('description', '')}
+        Amenities: {data.get('amenities', '')}
+        """
+    
+    def _run_summary_analysis(self, data):
+        """Run property summary analysis"""
+        try:
+            from .property_summary import generate_property_summary
+            return generate_property_summary(data)
+        except Exception as e:
+            logger.error(f"Error in summary analysis: {str(e)}")
+            return "Property summary unavailable."
+    
+    def _run_fraud_analysis(self, consolidated_text, data):
+        """Run fraud classification analysis"""
+        try:
+            from .fraud_classification import classify_fraud
+            return classify_fraud(data, consolidated_text)
+        except Exception as e:
+            logger.error(f"Error in fraud analysis: {str(e)}")
+            return self._get_error_result("Fraud analysis failed")
+    
+    def _run_trust_analysis(self, consolidated_text, image_analysis, pdf_analysis):
+        """Run trust score analysis"""
+        try:
+            from .trust_score import generate_trust_score
+            return generate_trust_score(consolidated_text, image_analysis, pdf_analysis)
+        except Exception as e:
+            logger.error(f"Error in trust analysis: {str(e)}")
+            return (0.0, "Trust analysis failed")
+    
+    def _run_suggestions_analysis(self, consolidated_text, data):
+        """Run suggestions analysis"""
+        try:
+            from .suggestions import generate_suggestions
+            return generate_suggestions(consolidated_text, data)
+        except Exception as e:
+            logger.error(f"Error in suggestions analysis: {str(e)}")
+            return self._get_error_result("Suggestions analysis failed")
+    
+    def _run_quality_analysis(self, description):
+        """Run text quality analysis"""
+        try:
+            from .text_quality import assess_text_quality
+            return assess_text_quality(description)
+        except Exception as e:
+            logger.error(f"Error in quality analysis: {str(e)}")
+            return self._get_error_result("Quality analysis failed")
+    
+    def _run_address_analysis(self, data):
+        """Run address verification analysis"""
+        try:
+            from .address_verification import verify_address
+            return verify_address(data)
+        except Exception as e:
+            logger.error(f"Error in address analysis: {str(e)}")
+            return self._get_error_result("Address analysis failed")
+    
+    def _run_cross_validation_analysis(self, data):
+        """Run cross validation analysis"""
+        try:
+            from .cross_validation import perform_cross_validation
+            return perform_cross_validation(data)
+        except Exception as e:
+            logger.error(f"Error in cross validation analysis: {str(e)}")
+            return self._get_error_result("Cross validation analysis failed")
+    
+    def _run_location_analysis(self, data):
+        """Run location analysis"""
+        try:
+            from .location_analysis import analyze_location
+            return analyze_location(data)
+        except Exception as e:
+            logger.error(f"Error in location analysis: {str(e)}")
+            return self._get_error_result("Location analysis failed")
+    
+    def _run_price_analysis(self, data, price_context, property_data):
+        """Run price analysis"""
+        try:
+            from .price_analysis import analyze_price
+            return analyze_price(data, price_context, data.get('latitude'), data.get('longitude'), property_data)
+        except Exception as e:
+            logger.error(f"Error in price analysis: {str(e)}")
+            return self._get_error_result("Price analysis failed")
+    
+    def _run_legal_analysis(self, legal_details):
+        """Run legal analysis"""
+        try:
+            from .legal_analysis import analyze_legal_details
+            return analyze_legal_details(legal_details)
+        except Exception as e:
+            logger.error(f"Error in legal analysis: {str(e)}")
+            return self._get_error_result("Legal analysis failed")
+    
+    def _run_specs_analysis(self, data):
+        """Run property specs analysis"""
+        try:
+            from .property_specs import verify_property_specs
+            return verify_property_specs(data)
+        except Exception as e:
+            logger.error(f"Error in specs analysis: {str(e)}")
+            return self._get_error_result("Specs analysis failed")
+    
+    def _run_market_analysis(self, data):
+        """Run market value analysis"""
+        try:
+            from .market_value import analyze_market_value
+            return analyze_market_value(data)
+        except Exception as e:
+            logger.error(f"Error in market analysis: {str(e)}")
+            return self._get_error_result("Market analysis failed")
+    
+    def _get_error_result(self, error_message):
+        """Get a standardized error result"""
+        return {
+            'error': error_message,
+            'status': 'error',
+            'confidence': 0.0
+        }
+    
+    def _get_all_error_results(self, error_message):
+        """Get error results for all analyses"""
+        return {
+            'summary': "Analysis failed",
+            'fraud': self._get_error_result(error_message),
+            'trust': (0.0, error_message),
+            'suggestions': self._get_error_result(error_message),
+            'quality': self._get_error_result(error_message),
+            'address': self._get_error_result(error_message),
+            'cross_validation': self._get_error_result(error_message),
+            'location': self._get_error_result(error_message),
+            'price': self._get_error_result(error_message),
+            'legal': self._get_error_result(error_message),
+            'specs': self._get_error_result(error_message),
+            'market': self._get_error_result(error_message)
+        }
+
+# Global instance for easy import
+parallel_processor = ParallelProcessor() 

models/performance_optimizer.py

@@ -0,0 +1,178 @@
+# models/performance_optimizer.py
+
+import functools
+import time
+import threading
+from typing import Dict, Any, Optional
+from .logging_config import logger
+
+class PerformanceOptimizer:
+    """Performance optimization utilities for the property verification system"""
+    
+    def __init__(self):
+        self._cache = {}
+        self._cache_lock = threading.Lock()
+        self._cache_ttl = 300  # 5 minutes cache TTL
+        self._cache_timestamps = {}
+    
+    def cache_result(self, key: str, result: Any, ttl: int = None) -> None:
+        """Cache a result with TTL"""
+        with self._cache_lock:
+            self._cache[key] = result
+            self._cache_timestamps[key] = time.time() + (ttl or self._cache_ttl)
+    
+    def get_cached_result(self, key: str) -> Optional[Any]:
+        """Get cached result if not expired"""
+        with self._cache_lock:
+            if key in self._cache:
+                if time.time() < self._cache_timestamps.get(key, 0):
+                    return self._cache[key]
+                else:
+                    # Remove expired cache entry
+                    del self._cache[key]
+                    if key in self._cache_timestamps:
+                        del self._cache_timestamps[key]
+            return None
+    
+    def clear_cache(self) -> None:
+        """Clear all cached results"""
+        with self._cache_lock:
+            self._cache.clear()
+            self._cache_timestamps.clear()
+    
+    def get_cache_stats(self) -> Dict[str, Any]:
+        """Get cache statistics"""
+        with self._cache_lock:
+            return {
+                'cache_size': len(self._cache),
+                'cache_keys': list(self._cache.keys()),
+                'cache_ttl': self._cache_ttl
+            }
+
+# Global performance optimizer instance
+performance_optimizer = PerformanceOptimizer()
+
+def timed_function(func):
+    """Decorator to time function execution"""
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        try:
+            result = func(*args, **kwargs)
+            execution_time = time.time() - start_time
+            logger.info(f"{func.__name__} executed in {execution_time:.2f} seconds")
+            return result
+        except Exception as e:
+            execution_time = time.time() - start_time
+            logger.error(f"{func.__name__} failed after {execution_time:.2f} seconds: {str(e)}")
+            raise
+    return wrapper
+
+def cached_function(ttl: int = 300):
+    """Decorator to cache function results"""
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            # Create cache key from function name and arguments
+            cache_key = f"{func.__name__}:{hash(str(args) + str(sorted(kwargs.items())))}"
+            
+            # Try to get cached result
+            cached_result = performance_optimizer.get_cached_result(cache_key)
+            if cached_result is not None:
+                logger.debug(f"Cache hit for {func.__name__}")
+                return cached_result
+            
+            # Execute function and cache result
+            result = func(*args, **kwargs)
+            performance_optimizer.cache_result(cache_key, result, ttl)
+            logger.debug(f"Cached result for {func.__name__}")
+            return result
+        return wrapper
+    return decorator
+
+def optimize_model_loading():
+    """Optimize model loading for better performance"""
+    try:
+        from .model_loader import load_model
+        
+        # Pre-load models in background threads
+        import concurrent.futures
+        import threading
+        
+        def load_model_async(model_name):
+            try:
+                model = load_model(model_name)
+                logger.info(f"Pre-loaded model: {model_name}")
+                return model
+            except Exception as e:
+                logger.warning(f"Failed to pre-load model {model_name}: {str(e)}")
+                return None
+        
+        # Load models in parallel
+        with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
+            model_names = [
+                "zero-shot-classification",
+                "summarization", 
+                "text-classification",
+                "text-generation"
+            ]
+            
+            futures = {executor.submit(load_model_async, name): name for name in model_names}
+            
+            for future in concurrent.futures.as_completed(futures, timeout=60):
+                model_name = futures[future]
+                try:
+                    future.result()
+                except Exception as e:
+                    logger.error(f"Error pre-loading {model_name}: {str(e)}")
+        
+        logger.info("Model pre-loading optimization completed")
+        
+    except Exception as e:
+        logger.error(f"Error in model loading optimization: {str(e)}")
+
+def optimize_image_processing():
+    """Optimize image processing for better performance"""
+    try:
+        from PIL import Image
+        import io
+        
+        # Set PIL to use optimized settings
+        Image.MAX_IMAGE_PIXELS = None  # Allow large images
+        
+        # Optimize JPEG quality for faster processing
+        def optimize_image(img, max_size=1024):
+            """Optimize image for faster processing"""
+            if max(img.size) > max_size:
+                img.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
+            return img
+        
+        return optimize_image
+        
+    except Exception as e:
+        logger.error(f"Error in image processing optimization: {str(e)}")
+        return lambda img, max_size=1024: img
+
+def get_performance_metrics():
+    """Get current performance metrics"""
+    import psutil
+    import os
+    
+    try:
+        process = psutil.Process(os.getpid())
+        memory_info = process.memory_info()
+        
+        return {
+            'memory_usage_mb': memory_info.rss / 1024 / 1024,
+            'cpu_percent': process.cpu_percent(),
+            'cache_stats': performance_optimizer.get_cache_stats(),
+            'thread_count': threading.active_count()
+        }
+    except Exception as e:
+        logger.error(f"Error getting performance metrics: {str(e)}")
+        return {
+            'memory_usage_mb': 0,
+            'cpu_percent': 0,
+            'cache_stats': {},
+            'thread_count': 0
+        } 

models/property_summary.py

@@ -273,16 +273,102 @@ def generate_fallback_summary(data):
 def generate_property_summary(data):
     """Main function to generate property summary using SLM"""
     try:
-        # Use the new dynamic SLM-based approach
-        summary = generate_dynamic_summary_with_slm(data)
-        if not summary or not summary.strip():
-            summary = generate_fallback_summary(data)
-        if not summary or not summary.strip():
-            summary = "A beautiful property with excellent features and location. Contact us for more details."
-        return summary
+        # Validate input data
+        if not data or not isinstance(data, dict):
+            return "A beautiful property with excellent features and prime location. Contact us for detailed information and exclusive offers."
+        
+        # Create a more robust fallback summary for any data
+        try:
+            # Use the new dynamic SLM-based approach
+            summary = generate_dynamic_summary_with_slm(data)
+            
+            # Ensure summary is a proper string
+            if not summary or not isinstance(summary, str):
+                summary = generate_fallback_summary(data)
+            
+            if not summary or not summary.strip():
+                summary = generate_fallback_summary(data)
+            
+            # Final fallback - always return something meaningful
+            if not summary or not summary.strip():
+                summary = "A beautiful property with excellent features and prime location. Contact us for detailed information and exclusive offers."
+            
+            # Ensure it's a string and clean it up
+            summary = str(summary).strip()
+            if summary == '[object Object]' or summary == 'null' or summary == 'undefined':
+                summary = generate_fallback_summary(data)
+            
+            # If still no valid summary, create a basic one
+            if not summary or len(summary) < 50:
+                summary = create_basic_summary(data)
+            
+            return summary
+            
+        except Exception as e:
+            logger.error(f"Error in summary generation: {str(e)}")
+            return create_basic_summary(data)
+        
     except Exception as e:
         logger.error(f"Error generating property summary: {str(e)}")
-        summary = generate_fallback_summary(data)
-        if not summary or not summary.strip():
-            summary = "A beautiful property with excellent features and location. Contact us for more details."
-        return summary
+        return "A beautiful property with excellent features and prime location. Contact us for detailed information and exclusive offers."
+
+def create_basic_summary(data):
+    """Create a basic summary even for invalid data"""
+    try:
+        # Extract basic information
+        property_type = data.get('property_type', 'Property')
+        city = data.get('city', 'Prime Location')
+        state = data.get('state', '')
+        bedrooms = data.get('bedrooms', '')
+        bathrooms = data.get('bathrooms', '')
+        sq_ft = data.get('sq_ft', '')
+        market_value = data.get('market_value', '')
+        
+        # Create location string
+        location_parts = []
+        if city:
+            location_parts.append(city)
+        if state:
+            location_parts.append(state)
+        location = ', '.join(location_parts) if location_parts else 'Prime Location'
+        
+        # Create features string
+        features = []
+        if bedrooms:
+            features.append(f"{bedrooms} bedroom{'s' if str(bedrooms) != '1' else ''}")
+        if bathrooms:
+            features.append(f"{bathrooms} bathroom{'s' if str(bathrooms) != '1' else ''}")
+        if sq_ft:
+            features.append(f"{sq_ft} sq. ft.")
+        
+        features_str = ', '.join(features) if features else 'excellent features'
+        
+        # Create price string
+        price_str = ""
+        if market_value:
+            try:
+                price_val = float(str(market_value).replace(',', '').replace('₹', ''))
+                if price_val > 0:
+                    price_str = f" at ₹{price_val:,.0f}"
+            except:
+                pass
+        
+        # Create property name - use a generic name if the original is invalid
+        property_name = data.get('property_name', '')
+        if property_name in ['2', '0', '1', 'test', 'sample', 'dummy'] or len(str(property_name)) < 3:
+            property_name = f"Beautiful {property_type}"
+        
+        # Build the summary
+        summary_parts = [
+            f"Discover this exceptional {property_type.lower()} located in {location}.",
+            f"This property features {features_str} and offers excellent value for money.",
+            f"Perfect for families and investors alike, this property combines modern amenities with strategic location.",
+            f"Don't miss this opportunity to own a piece of prime real estate{price_str}.",
+            "Contact us today for a detailed viewing and exclusive offers."
+        ]
+        
+        return " ".join(summary_parts)
+        
+    except Exception as e:
+        logger.error(f"Error creating basic summary: {str(e)}")
+        return "A beautiful property with excellent features and prime location. Contact us for detailed information and exclusive offers."

models/trust_score.py

@@ -9,7 +9,7 @@ def generate_trust_score(text, image_analysis, pdf_analysis):
             classifier = load_model("zero-shot-classification", "typeform/mobilebert-uncased-mnli")
         except Exception as e:
             logger.error(f"Error loading model in trust score: {str(e)}")
-            return 20, f"Model loading error: {str(e)}"
+            return 35, f"Model loading error: {str(e)}"
         aspects = [
             "complete information provided",
             "verified location",
@@ -24,16 +24,16 @@ def generate_trust_score(text, image_analysis, pdf_analysis):
             result = classifier(str(text)[:1000], aspects, multi_label=True)
         except Exception as e:
             logger.error(f"Error in trust score model inference: {str(e)}")
-            return 20, f"Model inference error: {str(e)}"
+            return 35, f"Model inference error: {str(e)}"
 
-        # Much stricter weights with higher emphasis on critical aspects
+        # More balanced weights
         weights = {
-            "complete information provided": 0.25,
+            "complete information provided": 0.20,
             "verified location": 0.20,
             "consistent data": 0.15,
             "authentic documents": 0.15,
             "authentic images": 0.10,
-            "reasonable pricing": 0.05,
+            "reasonable pricing": 0.10,
             "verified ownership": 0.05,
             "proper documentation": 0.05
         }
@@ -41,88 +41,97 @@ def generate_trust_score(text, image_analysis, pdf_analysis):
         score = 0
         reasoning_parts = []
 
-        # Much stricter scoring for each aspect
+        # More reasonable scoring for each aspect
         for label, confidence in zip(result['labels'], result['scores']):
             adjusted_confidence = confidence
 
-            # Stricter document verification
+            # Document verification
             if label == "authentic documents":
                 if not pdf_analysis or len(pdf_analysis) == 0:
-                    adjusted_confidence = 0.0
+                    adjusted_confidence = 0.3  # Base score for no documents
                 else:
                     doc_scores = [p.get('verification_score', 0) for p in pdf_analysis]
                     adjusted_confidence = sum(doc_scores) / max(1, len(doc_scores))
-                    # Heavily penalize if any document has low verification score
-                    if any(score < 0.7 for score in doc_scores):
-                        adjusted_confidence *= 0.4
-                    # Additional penalty for missing documents
+                    # Moderate penalty for low verification scores
+                    if any(score < 0.5 for score in doc_scores):
+                        adjusted_confidence *= 0.7
+                    # Small penalty for missing documents
                     if len(doc_scores) < 2:
-                        adjusted_confidence *= 0.5
+                        adjusted_confidence *= 0.8
 
-            # Stricter image verification
+            # Image verification
             elif label == "authentic images":
                 if not image_analysis or len(image_analysis) == 0:
-                    adjusted_confidence = 0.0
+                    adjusted_confidence = 0.3  # Base score for no images
                 else:
                     img_scores = [i.get('authenticity_score', 0) for i in image_analysis]
                     adjusted_confidence = sum(img_scores) / max(1, len(img_scores))
-                    # Heavily penalize if any image has low authenticity score
-                    if any(score < 0.8 for score in img_scores):
-                        adjusted_confidence *= 0.4
-                    # Additional penalty for AI-generated images
+                    # Moderate penalty for low authenticity scores
+                    if any(score < 0.6 for score in img_scores):
+                        adjusted_confidence *= 0.7
+                    # Small penalty for AI-generated images
                     if any(i.get('is_ai_generated', False) for i in image_analysis):
-                        adjusted_confidence *= 0.5
-                    # Additional penalty for non-property related images
+                        adjusted_confidence *= 0.8
+                    # Small penalty for non-property related images
                     if any(not i.get('is_property_related', False) for i in image_analysis):
-                        adjusted_confidence *= 0.6
+                        adjusted_confidence *= 0.8
 
-            # Stricter consistency check
+            # Consistency check
             elif label == "consistent data":
                 # Check for inconsistencies in the data
                 if "inconsistent" in text.lower() or "suspicious" in text.lower():
-                    adjusted_confidence *= 0.3
+                    adjusted_confidence *= 0.6
                 # Check for impossible values
                 if "impossible" in text.lower() or "invalid" in text.lower():
-                    adjusted_confidence *= 0.2
+                    adjusted_confidence *= 0.5
                 # Check for missing critical information
                 if "missing" in text.lower() or "not provided" in text.lower():
-                    adjusted_confidence *= 0.4
+                    adjusted_confidence *= 0.7
 
-            # Stricter completeness check
+            # Completeness check
             elif label == "complete information provided":
                 # Check for missing critical information
-                if len(text) < 300 or "not provided" in text.lower() or "missing" in text.lower():
-                    adjusted_confidence *= 0.4
+                if len(text) < 200 or "not provided" in text.lower() or "missing" in text.lower():
+                    adjusted_confidence *= 0.7
                 # Check for vague or generic descriptions
                 if "generic" in text.lower() or "vague" in text.lower():
-                    adjusted_confidence *= 0.5
+                    adjusted_confidence *= 0.8
                 # Check for suspiciously short descriptions
-                if len(text) < 150:
-                    adjusted_confidence *= 0.3
+                if len(text) < 100:
+                    adjusted_confidence *= 0.6
 
             score += adjusted_confidence * weights.get(label, 0.1)
             reasoning_parts.append(f"{label} ({adjusted_confidence:.0%})")
 
-        # Apply additional penalties for suspicious patterns
+        # Apply moderate penalties for suspicious patterns
         if "suspicious" in text.lower() or "fraudulent" in text.lower():
-            score *= 0.5
+            score *= 0.7
 
-        # Apply penalties for suspiciously low values
+        # Apply moderate penalties for suspiciously low values
         if "suspiciously low" in text.lower() or "unusually small" in text.lower():
-            score *= 0.6
+            score *= 0.8
 
-        # Apply penalties for inconsistencies
+        # Apply moderate penalties for inconsistencies
         if "inconsistent" in text.lower() or "mismatch" in text.lower():
-            score *= 0.6
+            score *= 0.8
 
-        # Apply penalties for missing critical information
+        # Apply moderate penalties for missing critical information
         if "missing critical" in text.lower() or "incomplete" in text.lower():
-            score *= 0.7
+            score *= 0.8
+
+        # Ensure minimum score for any valid data
+        if score < 0.1:
+            score = 0.1  # Minimum 10% score for any data
 
         # Ensure score is between 0 and 100
         score = min(100, max(0, int(score * 100)))
+        
+        # Ensure minimum score of 25% for any valid data
+        if score < 25:
+            score = 25
+            
         reasoning = f"Based on: {', '.join(reasoning_parts)}"
         return score, reasoning
     except Exception as e:
         logger.error(f"Error generating trust score: {str(e)}")
-        return 20, "Could not assess trust."
+        return 35, "Could not assess trust."