Upload app.py

app.py

@@ -15,6 +15,8 @@ from datetime import datetime
 # from deep_translator import GoogleTranslator
 from models.logging_config import logger
 from models.model_loader import load_model, clear_model_cache
+from models.parallel_processor import parallel_processor
+from models.performance_optimizer import performance_optimizer, optimize_model_loading, timed_function
 from models.image_analysis import analyze_image
 from models.pdf_analysis import extract_pdf_text, analyze_pdf_content
 from models.property_summary import generate_property_summary
@@ -43,28 +45,16 @@ CORS(app)  # Enable CORS for frontend
 geocoder = Nominatim(user_agent="indian_property_verifier", timeout=10)
 
 # Pre-load models to avoid loading delays during requests
+@timed_function
 def preload_models():
     """Pre-load essential models to improve response times."""
     try:
-        logger.info("Pre-loading essential models...")
+        logger.info("Pre-loading essential models with performance optimization...")
         
-        # Load models in parallel
-        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
-            futures = {
-                executor.submit(load_model, "zero-shot-classification"): "zero-shot-classification",
-                executor.submit(load_model, "summarization"): "summarization",
-                executor.submit(load_model, "text-classification"): "text-classification"
-            }
-            
-            for future in concurrent.futures.as_completed(futures, timeout=60):
-                model_type = futures[future]
-                try:
-                    model = future.result()
-                    logger.info(f"Successfully pre-loaded {model_type} model")
-                except Exception as e:
-                    logger.warning(f"Failed to pre-load {model_type} model: {str(e)}")
+        # Use the performance optimizer for model loading
+        optimize_model_loading()
         
-        logger.info("Model pre-loading completed")
+        logger.info("Model pre-loading completed with optimization")
     except Exception as e:
         logger.error(f"Error during model pre-loading: {str(e)}")
 
@@ -189,6 +179,42 @@ def get_location():
             'message': str(e)
         }), 500
 
+@app.route('/performance', methods=['GET'])
+def get_performance_metrics():
+    """Get system performance metrics and cache statistics"""
+    try:
+        from models.performance_optimizer import get_performance_metrics
+        
+        metrics = get_performance_metrics()
+        
+        return jsonify({
+            'status': 'success',
+            'metrics': metrics,
+            'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        })
+    except Exception as e:
+        logger.error(f"Error getting performance metrics: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': str(e)
+        }), 500
+
+@app.route('/clear-cache', methods=['POST'])
+def clear_cache():
+    """Clear all cached results"""
+    try:
+        performance_optimizer.clear_cache()
+        return jsonify({
+            'status': 'success',
+            'message': 'Cache cleared successfully'
+        })
+    except Exception as e:
+        logger.error(f"Error clearing cache: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': str(e)
+        }), 500
+
 def calculate_final_verdict(results):
     """
     Calculate a comprehensive final verdict based on all analysis results.
@@ -198,140 +224,255 @@ def calculate_final_verdict(results):
     try:
         # Defensive: ensure results is a dict
         if not isinstance(results, dict):
-            logger.warning(f"Input to calculate_final_verdict is not a dict: {type(results)}")
-            results = {}
+            logger.warning(f"Results is not a dict: {type(results)}")
+            return {
+                'verdict': 'VERIFICATION REQUIRED',
+                'confidence': 0.0,
+                'reasoning': 'Insufficient data for verification',
+                'risk_level': 'medium',
+                'overall_score': 25
+            }
+
+        # Extract key metrics with defensive programming
+        fraud_classification = results.get('fraud_classification', {})
+        trust_score_data = results.get('trust_score', {})
+        address_verification = results.get('address_verification', {})
+        cross_validation = results.get('cross_validation', [])
+        location_analysis = results.get('location_analysis', {})
+        price_analysis = results.get('price_analysis', {})
+        legal_analysis = results.get('legal_analysis', {})
+        specs_verification = results.get('specs_verification', {})
+        quality_assessment = results.get('quality_assessment', {})
+
+        # Calculate fraud risk score
+        fraud_score = 0.0
+        fraud_level = fraud_classification.get('alert_level', 'minimal')
+        fraud_alert_score = fraud_classification.get('alert_score', 0.0)
         
-        # Extract key components from results, defaulting to safe values
-        trust_score = results.get('trust_score', {}).get('score', 0) or 0
-        fraud_classification = results.get('fraud_classification', {}) or {}
-        quality_assessment = results.get('quality_assessment', {}) or {}
-        specs_verification = results.get('specs_verification', {}) or {}
-        cross_validation = results.get('cross_validation', []) or []
-        location_analysis = results.get('location_analysis', {}) or {}
-        price_analysis = results.get('price_analysis', {}) or {}
-        legal_analysis = results.get('legal_analysis', {}) or {}
-        document_analysis = results.get('document_analysis', {}) or {}
-        image_analysis = results.get('image_analysis', {}) or {}
+        fraud_score_mapping = {
+            'critical': 1.0,
+            'high': 0.8,
+            'medium': 0.6,
+            'low': 0.3,
+            'minimal': 0.1
+        }
+        fraud_score = fraud_score_mapping.get(fraud_level, 0.1) * fraud_alert_score
+
+        # Calculate trust score
+        trust_score = 0.0
+        if isinstance(trust_score_data, dict):
+            trust_score = trust_score_data.get('score', 0.0)
+            # Convert percentage to decimal if needed
+            if trust_score > 1.0:
+                trust_score = trust_score / 100.0
+        elif isinstance(trust_score_data, tuple) and len(trust_score_data) > 0:
+            trust_score = trust_score_data[0]
+            # Convert percentage to decimal if needed
+            if trust_score > 1.0:
+                trust_score = trust_score / 100.0
+        else:
+            trust_score = 0.0
+
+        # Calculate address verification score
+        address_score = 0.0
+        if address_verification and isinstance(address_verification, dict):
+            verification_score = address_verification.get('verification_score', 0.0)
+            address_score = float(verification_score) / 100.0 if verification_score > 0 else 0.0
+
+        # Calculate location analysis score
+        location_score = 0.0
+        if location_analysis and isinstance(location_analysis, dict):
+            completeness_score = location_analysis.get('completeness_score', 0.0)
+            location_score = float(completeness_score) / 100.0 if completeness_score > 0 else 0.0
+
+        # Calculate price analysis score
+        price_score = 0.0
+        if price_analysis and isinstance(price_analysis, dict):
+            confidence = price_analysis.get('confidence', 0.0)
+            price_score = float(confidence) if confidence > 0 else 0.0
+
+        # Calculate legal analysis score
+        legal_score = 0.0
+        if legal_analysis and isinstance(legal_analysis, dict):
+            confidence = legal_analysis.get('confidence', 0.0)
+            legal_score = float(confidence) if confidence > 0 else 0.0
+
+        # Calculate specs verification score
+        specs_score = 0.0
+        if specs_verification and isinstance(specs_verification, dict):
+            verification_score = specs_verification.get('verification_score', 0.0)
+            specs_score = float(verification_score) / 100.0 if verification_score > 0 else 0.0
+
+        # Calculate quality assessment score
+        quality_score = 0.0
+        if quality_assessment and isinstance(quality_assessment, dict):
+            score = quality_assessment.get('score', 0.0)
+            quality_score = float(score) / 100.0 if score > 0 else 0.0
+
+        # Calculate cross validation issues
+        cross_validation_issues = 0
+        high_severity_issues = 0
+        medium_severity_issues = 0
         
-        # Count red flags from cross-validation
-        red_flags_count = 0
-        critical_issues = []
-        warnings = []
+        if isinstance(cross_validation, list):
+            cross_validation_issues = len(cross_validation)
+            for issue in cross_validation:
+                if isinstance(issue, dict):
+                    severity = issue.get('severity', 'low')
+                    if severity == 'high':
+                        high_severity_issues += 1
+                    elif severity == 'medium':
+                        medium_severity_issues += 1
+
+        # Weighted scoring system with improved weights
+        weights = {
+            'fraud': 0.30,      # Increased weight for fraud detection
+            'trust': 0.25,      # Increased weight for trust score
+            'address': 0.15,    # Address verification
+            'location': 0.10,   # Location analysis
+            'price': 0.10,      # Price analysis
+            'legal': 0.05,      # Legal analysis
+            'specs': 0.03,      # Specs verification
+            'quality': 0.02     # Quality assessment
+        }
+
+        # Calculate weighted score
+        weighted_score = (
+            (1.0 - fraud_score) * weights['fraud'] +
+            trust_score * weights['trust'] +
+            address_score * weights['address'] +
+            location_score * weights['location'] +
+            price_score * weights['price'] +
+            legal_score * weights['legal'] +
+            specs_score * weights['specs'] +
+            quality_score * weights['quality']
+        )
+
+        # Debug logging
+        logger.info(f"Score components: fraud={fraud_score:.3f}, trust={trust_score:.3f}, address={address_score:.3f}, location={location_score:.3f}, price={price_score:.3f}, legal={legal_score:.3f}, specs={specs_score:.3f}, quality={quality_score:.3f}")
+        logger.info(f"Weighted score before penalty: {weighted_score:.3f}")
+
+        # Adjust score based on cross validation issues
+        issue_penalty = 0.0
+        if high_severity_issues > 0:
+            issue_penalty += high_severity_issues * 0.08  # Reduced from 0.15 to 0.08 (8% penalty per high severity issue)
+        if medium_severity_issues > 0:
+            issue_penalty += medium_severity_issues * 0.04  # Reduced from 0.08 to 0.04 (4% penalty per medium severity issue)
         
-        for check in cross_validation:
-            if check.get('status') in ['invalid', 'suspicious', 'inconsistent']:
-                red_flags_count += 1
-                if check.get('status') == 'invalid':
-                    critical_issues.append(check.get('message', 'Invalid data detected'))
-                else:
-                    warnings.append(check.get('message', 'Suspicious data detected'))
+        weighted_score = max(0.0, weighted_score - issue_penalty)
         
-        # Count additional red flags
-        if quality_assessment.get('score', 0) < 30:
-            red_flags_count += 1
-            warnings.append("Low content quality score")
+        logger.info(f"Issue penalty: {issue_penalty:.3f}, Final weighted score: {weighted_score:.3f}")
+
+        # Ensure minimum score for any valid data
+        if any([trust_score > 0, address_score > 0, location_score > 0, price_score > 0]):
+            weighted_score = max(0.15, weighted_score)  # Increased minimum from 0.1 to 0.15 (15% minimum)
+
+        # Determine verdict and risk level with improved logic
+        if weighted_score >= 0.75 and fraud_score < 0.2 and high_severity_issues == 0:
+            verdict = 'VERIFIED REAL ESTATE LISTING'
+            risk_level = 'low'
+        elif weighted_score >= 0.60 and fraud_score < 0.4 and high_severity_issues <= 1:
+            verdict = 'LIKELY LEGITIMATE'
+            risk_level = 'low'
+        elif weighted_score >= 0.40 and fraud_score < 0.6 and high_severity_issues <= 2:
+            verdict = 'SUSPICIOUS LISTING'
+            risk_level = 'medium'
+        elif fraud_score >= 0.6 or weighted_score < 0.20 or high_severity_issues >= 3:
+            verdict = 'HIGH RISK LISTING'
+            risk_level = 'high'
+        elif weighted_score >= 0.20:
+            verdict = 'VERIFICATION REQUIRED'
+            risk_level = 'medium'
+        else:
+            verdict = 'INSUFFICIENT DATA'
+            risk_level = 'medium'
+
+        # Generate detailed reasoning
+        reasoning_parts = []
         
-        if price_analysis.get('assessment') in ['below_market', 'suspicious']:
-            red_flags_count += 1
-            warnings.append("Suspicious pricing detected")
+        if fraud_score > 0.3:
+            reasoning_parts.append(f"Fraud risk detected (level: {fraud_level})")
         
-        if document_analysis.get('pdf_count', 0) == 0:
-            red_flags_count += 1
-            warnings.append("No documents provided")
+        if trust_score < 0.5:
+            reasoning_parts.append(f"Low trust score ({trust_score:.1%})")
         
-        if image_analysis.get('image_count', 0) == 0:
-            red_flags_count += 1
-            warnings.append("No images provided")
+        if address_score < 0.5:
+            reasoning_parts.append("Address verification issues")
         
-        # Calculate component scores (0-100) with red flag penalties
-        component_scores = {
-            'trust': max(0, trust_score - (red_flags_count * 10)),
-            'fraud': max(0, 100 - (fraud_classification.get('alert_score', 0) * 100) - (red_flags_count * 15)),
-            'quality': max(0, quality_assessment.get('score', 0) - (red_flags_count * 5)),
-            'specs': max(0, specs_verification.get('verification_score', 0) - (red_flags_count * 10)),
-            'location': max(0, location_analysis.get('completeness_score', 0) - (red_flags_count * 5)),
-            'price': max(0, (price_analysis.get('confidence', 0) * 100) - (red_flags_count * 10)) if price_analysis.get('has_price') else 0,
-            'legal': max(0, legal_analysis.get('completeness_score', 0) - (red_flags_count * 5)),
-            'documents': max(0, min(100, (document_analysis.get('pdf_count', 0) / 3) * 100) - (red_flags_count * 10)),
-            'images': max(0, min(100, (image_analysis.get('image_count', 0) / 5) * 100) - (red_flags_count * 10))
-        }
+        if location_score < 0.5:
+            reasoning_parts.append("Location verification issues")
         
-        # Calculate weighted final score with adjusted weights
-        weights = {
-            'trust': 0.20,
-            'fraud': 0.25,  # Increased weight for fraud detection
-            'quality': 0.15,
-            'specs': 0.10,
-            'location': 0.10,
-            'price': 0.05,
-            'legal': 0.05,
-            'documents': 0.05,
-            'images': 0.05
-        }
+        if price_score < 0.5:
+            reasoning_parts.append("Price analysis concerns")
         
-        final_score = sum(component_scores[component] * weights[component] for component in weights)
+        if legal_score < 0.5:
+            reasoning_parts.append("Legal documentation issues")
         
-        # Ensure final score is capped at 100%
-        final_score = min(100, max(0, final_score))
+        if high_severity_issues > 0:
+            reasoning_parts.append(f"{high_severity_issues} critical validation issues")
         
-        # Determine verdict based on final score, fraud indicators, and red flags
-        fraud_level = fraud_classification.get('alert_level', 'minimal')
-        high_risk_indicators = len(fraud_classification.get('high_risk', []))
-        medium_risk_indicators = len(fraud_classification.get('medium_risk', []))
+        if medium_severity_issues > 0:
+            reasoning_parts.append(f"{medium_severity_issues} moderate validation issues")
         
-        # Strong red flag penalties
-        if red_flags_count >= 5 or len(critical_issues) >= 2:
-            verdict = 'fraudulent'
-            confidence = 'high'
-        elif fraud_level in ['critical', 'high'] or high_risk_indicators > 0:
-            verdict = 'fraudulent'
-            confidence = 'high'
-        elif fraud_level == 'medium' or medium_risk_indicators > 2 or red_flags_count >= 3:
-            verdict = 'suspicious'
-            confidence = 'medium'
-        elif final_score >= 80 and red_flags_count <= 1:
-            verdict = 'legitimate'
-            confidence = 'high'
-        elif final_score >= 60 and red_flags_count <= 2:
-            verdict = 'legitimate'
-            confidence = 'medium'
-        elif final_score >= 40 and red_flags_count <= 3:
-            verdict = 'suspicious'
-            confidence = 'medium'
-        else:
-            verdict = 'suspicious'
-            confidence = 'high'
+        if not reasoning_parts:
+            reasoning_parts.append("All verification checks passed successfully")
+
+        reasoning = ". ".join(reasoning_parts)
         
+        # Calculate overall score as percentage
+        overall_score = int(weighted_score * 100)
+        
+        # Ensure score is between 0 and 100
+        overall_score = max(0, min(100, overall_score))
+        
+        # Ensure minimum score for any valid data
+        if overall_score == 0 and any([trust_score > 0, address_score > 0, location_score > 0]):
+            overall_score = 15  # Minimum 15% score if any component is valid
+        
+        # Final score adjustment based on data quality
+        if high_severity_issues >= 3:
+            overall_score = max(10, overall_score)  # Minimum 10% for high risk
+        elif high_severity_issues >= 1:
+            overall_score = max(15, overall_score)  # Minimum 15% for medium risk
+        else:
+            overall_score = max(20, overall_score)  # Minimum 20% for low risk
+
         return {
             'verdict': verdict,
-            'confidence': confidence,
-            'final_score': round(final_score, 2),
-            'component_scores': component_scores,
-            'fraud_level': fraud_level,
-            'risk_indicators': {
-                'high': high_risk_indicators,
-                'medium': medium_risk_indicators,
-                'total_red_flags': red_flags_count
-            },
-            'critical_issues': critical_issues,
-            'warnings': warnings
+            'confidence': min(1.0, weighted_score),
+            'reasoning': reasoning,
+            'risk_level': risk_level,
+            'overall_score': overall_score,
+            'scores': {
+                'fraud_score': fraud_score,
+                'trust_score': trust_score,
+                'address_score': address_score,
+                'location_score': location_score,
+                'price_score': price_score,
+                'legal_score': legal_score,
+                'specs_score': specs_score,
+                'quality_score': quality_score,
+                'weighted_score': weighted_score,
+                'cross_validation_issues': cross_validation_issues,
+                'high_severity_issues': high_severity_issues
+            }
         }
+
     except Exception as e:
         logger.error(f"Error calculating final verdict: {str(e)}")
         return {
-            'verdict': 'suspicious',
-            'confidence': 'low',
-            'final_score': 0,
-            'component_scores': {},
-            'fraud_level': 'unknown',
-            'risk_indicators': {'high': 0, 'medium': 0, 'total_red_flags': 0},
-            'critical_issues': ['Error in calculation'],
-            'warnings': ['System error occurred']
+            'verdict': 'VERIFICATION REQUIRED',
+            'confidence': 0.0,
+            'reasoning': f'Error in verdict calculation: {str(e)}',
+            'risk_level': 'medium',
+            'overall_score': 25
         }
 
 @app.route('/verify', methods=['POST'])
 def verify_property():
     try:
+        start_time = time.time()
+        
         if not request.form and not request.files:
             logger.warning("No form data or files provided")
             return jsonify({
@@ -374,51 +515,46 @@ def verify_property():
                 'status': 'error'
             }), 400
 
-        # Process images
+        # Process images in parallel
         images = []
         image_analysis = []
         if 'images' in request.files:
-            # Get unique image files by filename to prevent duplicates
-            image_files = {}
+            image_files = []
             for img_file in request.files.getlist('images'):
                 if img_file.filename and img_file.filename.lower().endswith(('.jpg', '.jpeg', '.png')):
-                    image_files[img_file.filename] = img_file
-
-            # Process unique images
-            for img_file in image_files.values():
-                    try:
-                        img = Image.open(img_file)
-                        buffered = io.BytesIO()
-                        img.save(buffered, format="JPEG")
-                        img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
-                        images.append(img_str)
-                        image_analysis.append(analyze_image(img))
-                    except Exception as e:
-                        logger.error(f"Error processing image {img_file.filename}: {str(e)}")
-                        image_analysis.append({'error': str(e), 'is_property_related': False})
-
-        # Process PDFs
+                    image_files.append(img_file)
+            
+            if image_files:
+                # Process images in parallel
+                image_results = parallel_processor.process_images_parallel(image_files)
+                for result in image_results:
+                    if 'image_data' in result:
+                        images.append(result['image_data'])
+                        image_analysis.append(result['analysis'])
+                    else:
+                        image_analysis.append(result)
+
+        # Process PDFs in parallel
         pdf_texts = []
         pdf_analysis = []
         if 'documents' in request.files:
-            # Get unique PDF files by filename to prevent duplicates
-            pdf_files = {}
+            pdf_files = []
             for pdf_file in request.files.getlist('documents'):
                 if pdf_file.filename and pdf_file.filename.lower().endswith('.pdf'):
-                    pdf_files[pdf_file.filename] = pdf_file
-
-            # Process unique PDFs
-            for pdf_file in pdf_files.values():
-                    try:
-                        pdf_text = extract_pdf_text(pdf_file)
+                    pdf_files.append(pdf_file)
+            
+            if pdf_files:
+                # Process PDFs in parallel
+                pdf_results = parallel_processor.process_pdfs_parallel(pdf_files)
+                for result in pdf_results:
+                    if 'filename' in result:
                         pdf_texts.append({
-                            'filename': pdf_file.filename,
-                            'text': pdf_text
+                            'filename': result['filename'],
+                            'text': result['text']
                         })
-                        pdf_analysis.append(analyze_pdf_content(pdf_text, data))
-                    except Exception as e:
-                        logger.error(f"Error processing PDF {pdf_file.filename}: {str(e)}")
-                        pdf_analysis.append({'error': str(e)})
+                        pdf_analysis.append(result['analysis'])
+                    else:
+                        pdf_analysis.append(result)
 
         # Create consolidated text for analysis
         consolidated_text = f"""
@@ -442,13 +578,6 @@ def verify_property():
         try:
             description = data['description']
             if description and len(description) > 10:
-                # Temporarily disable translation to avoid import errors
-                # text_language = detect(description)
-                # if text_language != 'en':
-                #     translated_description = GoogleTranslator(source=text_language, target='en').translate(description)
-                #     data['description_translated'] = translated_description
-                # else:
-                #     data['description_translated'] = description
                 data['description_translated'] = description
             else:
                 data['description_translated'] = description
@@ -456,68 +585,50 @@ def verify_property():
             logger.error(f"Error in language detection/translation: {str(e)}")
             data['description_translated'] = data['description']
 
-        # Run all analyses in parallel using asyncio
-        async def run_analyses():
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                loop = asyncio.get_event_loop()
-                
-                # Prepare property data for price analysis
-                property_data = {}
-                if data.get('sq_ft'):
-                    try:
-                        property_data['size'] = float(data['sq_ft'])
-                    except ValueError:
-                        pass
-                if data.get('market_value'):
-                    try:
-                        property_data['price'] = float(data['market_value'].replace('₹', '').replace(',', ''))
-                    except ValueError:
-                        pass
-                if data.get('year_built'):
-                    try:
-                        current_year = datetime.now().year
-                        property_data['property_age'] = current_year - int(data['year_built'])
-                    except ValueError:
-                        pass
-                
-                # Create context text for price analysis
-                price_context = f"""
-                Property: {data['property_name']}
-                Type: {data['property_type']}
-                Location: {data['address']}, {data['city']}, {data['state']}
-                Size: {data['sq_ft']} sq ft
-                Market Value: ₹{data['market_value']}
-                Description: {data['description']}
-                Amenities: {data['amenities']}
-                """
-                
-                tasks = [
-                    loop.run_in_executor(executor, generate_property_summary, data),
-                    loop.run_in_executor(executor, classify_fraud, consolidated_text, data),
-                    loop.run_in_executor(executor, generate_trust_score, consolidated_text, image_analysis, pdf_analysis),
-                    loop.run_in_executor(executor, generate_suggestions, consolidated_text, data),
-                    loop.run_in_executor(executor, assess_text_quality, data['description_translated']),
-                    loop.run_in_executor(executor, verify_address, data),
-                    loop.run_in_executor(executor, perform_cross_validation, data),
-                    loop.run_in_executor(executor, analyze_location, data),
-                    loop.run_in_executor(executor, lambda: analyze_price(data, price_context, data.get('latitude'), data.get('longitude'), property_data)),
-                    loop.run_in_executor(executor, analyze_legal_details, data['legal_details']),
-                    loop.run_in_executor(executor, verify_property_specs, data),
-                    loop.run_in_executor(executor, analyze_market_value, data)
-                ]
-                results = await asyncio.gather(*tasks)
-                return results
-
-        # Run analyses and get results
+        # Run all analyses in parallel using the new parallel processor
+        analysis_start_time = time.time()
+        
+        # Create new event loop for async operations
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-        analysis_results = loop.run_until_complete(run_analyses())
-        loop.close()
+        
+        try:
+            analysis_results = loop.run_until_complete(
+                parallel_processor.run_analyses_parallel(data, consolidated_text, image_analysis, pdf_analysis)
+            )
+        finally:
+            loop.close()
+
+        analysis_time = time.time() - analysis_start_time
+        logger.info(f"Analysis completed in {analysis_time:.2f} seconds")
 
         # Unpack results
-        summary, fraud_classification, (trust_score, trust_reasoning), suggestions, quality_assessment, \
-        address_verification, cross_validation, location_analysis, price_analysis, legal_analysis, \
-        specs_verification, market_analysis = analysis_results
+        summary = analysis_results.get('summary', "Property summary unavailable.")
+        
+        # Ensure summary is not placeholder text
+        if summary and isinstance(summary, str):
+            if "[Insert Property Description Here]" in summary or "[insert property price here]" in summary:
+                # Generate a basic summary if placeholder text is detected
+                from .property_summary import create_basic_summary
+                summary = create_basic_summary(data)
+        
+        fraud_classification = analysis_results.get('fraud', {})
+        trust_result = analysis_results.get('trust', (0.0, "Trust analysis failed"))
+        suggestions = analysis_results.get('suggestions', {})
+        quality_assessment = analysis_results.get('quality', {})
+        address_verification = analysis_results.get('address', {})
+        cross_validation = analysis_results.get('cross_validation', [])
+        location_analysis = analysis_results.get('location', {})
+        price_analysis = analysis_results.get('price', {})
+        legal_analysis = analysis_results.get('legal', {})
+        specs_verification = analysis_results.get('specs', {})
+        market_analysis = analysis_results.get('market', {})
+
+        # Handle trust score result
+        if isinstance(trust_result, tuple):
+            trust_score, trust_reasoning = trust_result
+        else:
+            trust_score, trust_reasoning = 0.0, "Trust analysis failed"
 
         # Prepare response
         document_analysis = {
@@ -553,13 +664,20 @@ def verify_property():
             'image_analysis': image_results,
             'specs_verification': specs_verification,
             'market_analysis': market_analysis,
-            'images': images
+            'images': images,
+            'processing_time': {
+                'total_time': time.time() - start_time,
+                'analysis_time': analysis_time
+            }
         }
 
         # Calculate final verdict
         final_verdict = calculate_final_verdict(results)
         results['final_verdict'] = final_verdict
 
+        total_time = time.time() - start_time
+        logger.info(f"Total verification completed in {total_time:.2f} seconds")
+
         return jsonify(make_json_serializable(results))
 
     except Exception as e: