Upload 22 files

app.py

@@ -244,7 +244,7 @@ def calculate_final_verdict(results):
                 'confidence': 0.0,
                 'reasoning': 'Insufficient data for verification',
                 'risk_level': 'medium',
-                'overall_score': 25
+                'overall_score': 50  # Increased from 25
             }
 
         # Extract key metrics with defensive programming
@@ -258,7 +258,7 @@ def calculate_final_verdict(results):
         specs_verification = results.get('specs_verification', {})
         quality_assessment = results.get('quality_assessment', {})
 
-        # CRITICAL: Check for fake data patterns in cross validation
+        # CRITICAL: Check for fake data patterns in cross validation - Much more lenient
         fake_data_detected = False
         fraudulent_issues = 0
         high_severity_issues = 0
@@ -281,24 +281,24 @@ def calculate_final_verdict(results):
                     elif severity == 'low':
                         low_severity_issues += 1
 
-        # Calculate fraud risk score - Much stricter
+        # Calculate fraud risk score - Much more lenient
         fraud_score = 0.0
         fraud_level = fraud_classification.get('alert_level', 'minimal')
         fraud_alert_score = fraud_classification.get('alert_score', 0.0)
         
         fraud_score_mapping = {
-            'critical': 1.0,  # Increased back to full penalty
-            'high': 0.8,      # Increased back to full penalty
-            'medium': 0.6,    # Increased back to full penalty
-            'low': 0.4,       # Increased penalty
-            'minimal': 0.1    # Increased penalty
+            'critical': 0.8,  # Reduced from 1.0
+            'high': 0.6,      # Reduced from 0.8
+            'medium': 0.4,    # Reduced from 0.6
+            'low': 0.2,       # Reduced from 0.4
+            'minimal': 0.05   # Reduced from 0.1
         }
-        fraud_score = fraud_score_mapping.get(fraud_level, 0.1) * fraud_alert_score
+        fraud_score = fraud_score_mapping.get(fraud_level, 0.05) * fraud_alert_score
 
-        # CRITICAL: Heavy penalty for fake data
+        # CRITICAL: Much more lenient penalty for fake data
         if fake_data_detected:
-            fraud_score = max(fraud_score, 0.8)  # Minimum 80% fraud score for fake data
-            fraud_level = 'high'
+            fraud_score = max(fraud_score, 0.4)  # Reduced from 0.8 to 0.4
+            fraud_level = 'medium'  # Changed from 'high' to 'medium'
 
         # Calculate trust score
         trust_score = 0.0
@@ -315,9 +315,9 @@ def calculate_final_verdict(results):
         else:
             trust_score = 0.0
 
-        # CRITICAL: Heavy penalty for fake data in trust score
+        # CRITICAL: Much more lenient penalty for fake data in trust score
         if fake_data_detected:
-            trust_score = max(0.0, trust_score - 0.5)  # Reduce trust score by 50% for fake data
+            trust_score = max(0.0, trust_score - 0.2)  # Reduced penalty from 0.5 to 0.2
 
         # Calculate address verification score
         address_score = 0.0
@@ -355,16 +355,16 @@ def calculate_final_verdict(results):
             score = quality_assessment.get('score', 0.0)
             quality_score = float(score) / 100.0 if score > 0 else 0.0
 
-        # Much stricter weighted scoring system
+        # Much more balanced weighted scoring system
         weights = {
-            'fraud': 0.35,      # Increased weight for fraud detection
-            'trust': 0.25,      # Keep trust score important
-            'address': 0.15,    # Address verification
-            'location': 0.10,   # Location analysis
-            'price': 0.10,      # Price analysis
-            'legal': 0.03,      # Legal analysis
-            'specs': 0.01,      # Specs verification
-            'quality': 0.01     # Quality assessment
+            'fraud': 0.25,      # Reduced from 0.35
+            'trust': 0.30,      # Increased from 0.25
+            'address': 0.15,    # Keep address verification
+            'location': 0.12,   # Increased from 0.10
+            'price': 0.10,      # Keep price analysis
+            'legal': 0.05,      # Increased from 0.03
+            'specs': 0.02,      # Increased from 0.01
+            'quality': 0.01     # Keep quality assessment
         }
 
         # Calculate weighted score
@@ -383,44 +383,44 @@ def calculate_final_verdict(results):
         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}")
 
-        # Much stricter penalty system
+        # Much more lenient penalty system
         issue_penalty = 0.0
         if fraudulent_issues > 0:
-            issue_penalty += fraudulent_issues * 0.15  # 15% penalty per fraudulent issue
+            issue_penalty += fraudulent_issues * 0.08  # Reduced from 0.15 to 0.08
         if high_severity_issues > 0:
-            issue_penalty += high_severity_issues * 0.10  # 10% penalty per high severity issue
+            issue_penalty += high_severity_issues * 0.05  # Reduced from 0.10 to 0.05
         if medium_severity_issues > 0:
-            issue_penalty += medium_severity_issues * 0.05  # 5% penalty per medium severity issue
+            issue_penalty += medium_severity_issues * 0.02  # Reduced from 0.05 to 0.02
         if low_severity_issues > 0:
-            issue_penalty += low_severity_issues * 0.02  # 2% penalty per low severity issue
+            issue_penalty += low_severity_issues * 0.01  # Reduced from 0.02 to 0.01
         
         weighted_score = max(0.0, weighted_score - issue_penalty)
         
         logger.info(f"Issue penalty: {issue_penalty:.3f}, Final weighted score: {weighted_score:.3f}")
 
-        # CRITICAL: Much stricter minimum score requirements
+        # CRITICAL: Much more lenient minimum score requirements
         if fake_data_detected:
-            weighted_score = max(0.05, weighted_score)  # Maximum 5% score for fake data
+            weighted_score = max(0.15, weighted_score)  # Increased from 0.05 to 0.15
         elif any([trust_score > 0, address_score > 0, location_score > 0, price_score > 0]):
-            weighted_score = max(0.15, weighted_score)  # Minimum 15% for any valid data
+            weighted_score = max(0.30, weighted_score)  # Increased from 0.15 to 0.30
 
-        # Less strict verdict determination
-        if fake_data_detected or fraudulent_issues > 2:
+        # Much more lenient verdict determination
+        if fake_data_detected and fraudulent_issues > 5:  # Increased threshold from 2 to 5
             verdict = 'HIGH RISK LISTING'
             risk_level = 'high'
-        elif weighted_score >= 0.70 and fraud_score < 0.3 and high_severity_issues == 0:
+        elif weighted_score >= 0.60 and fraud_score < 0.4 and high_severity_issues == 0:  # Reduced from 0.70 to 0.60
             verdict = 'VERIFIED REAL ESTATE LISTING'
             risk_level = 'low'
-        elif weighted_score >= 0.50 and fraud_score < 0.4 and high_severity_issues <= 1:
+        elif weighted_score >= 0.40 and fraud_score < 0.5 and high_severity_issues <= 2:  # Reduced from 0.50 to 0.40
             verdict = 'LIKELY LEGITIMATE'
             risk_level = 'low'
-        elif weighted_score >= 0.30 and fraud_score < 0.6 and high_severity_issues <= 2:
+        elif weighted_score >= 0.25 and fraud_score < 0.7 and high_severity_issues <= 3:  # Reduced from 0.30 to 0.25
             verdict = 'SUSPICIOUS LISTING'
             risk_level = 'medium'
-        elif fraud_score >= 0.7 or weighted_score < 0.15 or high_severity_issues >= 4:
+        elif fraud_score >= 0.8 or weighted_score < 0.20 or high_severity_issues >= 6:  # Much more lenient thresholds
             verdict = 'HIGH RISK LISTING'
             risk_level = 'high'
-        elif weighted_score >= 0.15:
+        elif weighted_score >= 0.20:  # Reduced from 0.15
             verdict = 'VERIFICATION REQUIRED'
             risk_level = 'medium'
         else:
@@ -436,22 +436,22 @@ def calculate_final_verdict(results):
         if fraudulent_issues > 0:
             reasoning_parts.append(f"{fraudulent_issues} fraudulent validation issues")
         
-        if fraud_score > 0.3:
+        if fraud_score > 0.4:  # Reduced from 0.3
             reasoning_parts.append(f"Fraud risk detected (level: {fraud_level})")
         
-        if trust_score < 0.3:
+        if trust_score < 0.4:  # Reduced from 0.3
             reasoning_parts.append(f"Low trust score ({trust_score:.1%})")
         
-        if address_score < 0.5:
+        if address_score < 0.6:  # Reduced from 0.5
             reasoning_parts.append("Address verification issues")
         
-        if location_score < 0.5:
+        if location_score < 0.6:  # Reduced from 0.5
             reasoning_parts.append("Location verification issues")
         
-        if price_score < 0.5:
+        if price_score < 0.6:  # Reduced from 0.5
             reasoning_parts.append("Price analysis concerns")
         
-        if legal_score < 0.5:
+        if legal_score < 0.6:  # Reduced from 0.5
             reasoning_parts.append("Legal documentation issues")
         
         if high_severity_issues > 0:
@@ -471,21 +471,21 @@ def calculate_final_verdict(results):
         # Ensure score is between 0 and 100
         overall_score = max(0, min(100, overall_score))
         
-        # CRITICAL: Less punitive minimum score for fake data
+        # CRITICAL: Much more lenient minimum score for fake data
         if fake_data_detected:
-            overall_score = max(10, min(25, overall_score))  # 10-25% range for fake data
+            overall_score = max(25, min(50, overall_score))  # Increased range from 10-25% to 25-50%
         elif overall_score == 0 and any([trust_score > 0, address_score > 0, location_score > 0]):
-            overall_score = 20  # Minimum 20% score if any component is valid
+            overall_score = 40  # Increased from 20 to 40
         
-        # Final score adjustment based on data quality - Less punitive
+        # Final score adjustment based on data quality - Much more lenient
         if fake_data_detected or fraudulent_issues > 0:
-            overall_score = max(10, min(25, overall_score))  # 10-25% for fake/fraudulent data
+            overall_score = max(25, min(50, overall_score))  # Increased from 10-25% to 25-50%
         elif high_severity_issues >= 3:
-            overall_score = max(15, overall_score)  # Minimum 15% for high risk
+            overall_score = max(30, overall_score)  # Increased from 15 to 30
         elif high_severity_issues >= 1:
-            overall_score = max(20, overall_score)  # Minimum 20% for medium risk
+            overall_score = max(40, overall_score)  # Increased from 20 to 40
         else:
-            overall_score = max(25, overall_score)  # Minimum 25% for low risk
+            overall_score = max(50, overall_score)  # Increased from 25 to 50
 
         return {
             'verdict': verdict,
@@ -519,7 +519,7 @@ def calculate_final_verdict(results):
             'confidence': 0.0,
             'reasoning': f'Error in verdict calculation: {str(e)}',
             'risk_level': 'medium',
-            'overall_score': 25
+            'overall_score': 50  # Increased from 25
         }
 
 @app.route('/verify', methods=['POST'])

models/address_verification.py

@@ -28,20 +28,20 @@ def verify_address(data):
         latitude = data.get('latitude', None)
         longitude = data.get('longitude', None)
 
-        # Basic validation - give points for having required fields
+        # Basic validation - give more points for having required fields
         basic_score = 0.0
         if zip_code:
-            basic_score += 0.2
+            basic_score += 0.25  # Increased from 0.2
         if city:
-            basic_score += 0.2
+            basic_score += 0.25  # Increased from 0.2
         if state:
-            basic_score += 0.2
+            basic_score += 0.25  # Increased from 0.2
         if address:
-            basic_score += 0.2
+            basic_score += 0.15  # Reduced from 0.2 since address is less critical
         if latitude and longitude:
-            basic_score += 0.2
+            basic_score += 0.10  # Reduced from 0.2 since coordinates are optional
 
-        # Pincode validation with fallback
+        # Pincode validation with much more lenient fallback
         if zip_code:
             try:
                 response = requests.get(f"https://api.postalpincode.in/pincode/{zip_code}", timeout=5)
@@ -62,18 +62,18 @@ def verify_address(data):
                     address_results['issues'].append("Pincode API error")
             except Exception as e:
                 logger.error(f"Pincode API error: {str(e)}")
-                # Don't fail completely - give partial credit for having pincode
+                # Much more lenient fallback - give credit for having pincode
                 if zip_code and len(zip_code) == 6 and zip_code.isdigit():
                     address_results['pincode_valid'] = True
                     address_results['issues'].append("Pincode validation failed (API error)")
                 else:
                     address_results['issues'].append("Pincode validation failed")
 
-        # Geocoding with fallback
+        # Geocoding with much more lenient fallback
         full_address = ', '.join(filter(None, [address, city, state, country, zip_code]))
         geocoding_success = False
         
-        for attempt in range(3):
+        for attempt in range(2):  # Reduced attempts from 3 to 2
             try:
                 location = geocoder.geocode(full_address)
                 if location:
@@ -87,7 +87,7 @@ def verify_address(data):
                             geocoded_coords = (location.latitude, location.longitude)
                             from geopy.distance import distance
                             dist = distance(provided_coords, geocoded_coords).km
-                            address_results['coordinates_match'] = dist < 1.0
+                            address_results['coordinates_match'] = dist < 2.0  # Increased from 1.0 to 2.0
                             if not address_results['coordinates_match']:
                                 address_results['issues'].append(f"Coordinates {dist:.2f}km off")
                         except Exception as e:
@@ -100,15 +100,19 @@ def verify_address(data):
                 time.sleep(1)
         
         if not geocoding_success:
-            # Fallback: if we have basic address components, give partial credit
+            # Much more lenient fallback: if we have basic address components, give good credit
             if address and city and state:
                 address_results['address_exists'] = True
-                address_results['confidence'] = 0.6
+                address_results['confidence'] = 0.8  # Increased from 0.6
+                address_results['issues'].append("Address geocoding failed (using fallback validation)")
+            elif city and state:  # Even more lenient - just city and state
+                address_results['address_exists'] = True
+                address_results['confidence'] = 0.7  # Good score for city/state
                 address_results['issues'].append("Address geocoding failed (using fallback validation)")
             else:
                 address_results['issues'].append("Address geocoding failed")
 
-        # Calculate verification score with fallback
+        # Calculate verification score with much more lenient fallback
         try:
             verification_points = (
                 float(address_results['address_exists']) * 0.4 +
@@ -117,24 +121,30 @@ def verify_address(data):
                 float(address_results['coordinates_match']) * 0.1
             )
             
-            # If external APIs failed but we have basic data, give minimum score
+            # Much more lenient fallback scoring
             if verification_points == 0.0 and basic_score > 0.0:
-                verification_points = basic_score * 0.5  # 50% of basic score as fallback
+                verification_points = basic_score * 0.8  # Increased from 0.5 to 0.8
                 
         except Exception as e:
             logger.warning(f"Error calculating verification points: {str(e)}")
-            verification_points = basic_score * 0.5  # Fallback to basic score
+            verification_points = basic_score * 0.8  # Increased fallback to basic score
         
-        # Ensure minimum score for valid data
+        # Much more lenient minimum score for valid data
         if verification_points == 0.0 and (zip_code or city or state or address):
-            verification_points = 0.2  # Minimum 20% for having some address data
+            verification_points = 0.4  # Increased from 0.2 to 0.4 (40% minimum)
+        
+        # Additional bonus for having multiple address components
+        if zip_code and city and state:
+            verification_points = min(1.0, verification_points + 0.1)  # 10% bonus
+        elif city and state:
+            verification_points = min(1.0, verification_points + 0.05)  # 5% bonus
         
         address_results['verification_score'] = verification_points * 100  # Convert to percentage
 
         return address_results
     except Exception as e:
         logger.error(f"Error verifying address: {str(e)}")
-        # Return minimum score instead of 0
+        # Return much higher minimum score instead of 0
         return {
             'address_exists': False,
             'pincode_valid': False,
@@ -142,5 +152,5 @@ def verify_address(data):
             'coordinates_match': False,
             'confidence': 0.0,
             'issues': [f"Address verification error: {str(e)}"],
-            'verification_score': 10.0  # Minimum 10% score instead of 0
+            'verification_score': 30.0  # Increased from 10.0 to 30.0
         }

models/cross_validation.py

@@ -460,9 +460,9 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
         fake_data_detected = False
         fake_indicators = []
         
-        # Check for numeric-only property names
+        # Check for numeric-only property names - Much more lenient
         property_name = data.get('property_name', '').strip()
-        if property_name.isdigit() or property_name in ['1', '2', '3', '4', '5']:
+        if property_name.isdigit() and len(property_name) <= 2:  # Only single/double digits
             fake_data_detected = True
             fake_indicators.append("Property name is just a number")
             analysis_sections['basic_info'].append({
@@ -474,9 +474,9 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                 'recommendation': 'Provide a real property name'
             })
         
-        # Check for suspiciously low values
+        # Check for suspiciously low values - Much more lenient
         market_value = safe_float_convert(data.get('market_value', 0))
-        if market_value <= 10:  # Extremely low threshold
+        if market_value <= 5:  # Extremely low threshold - only for obvious fake data
             fake_data_detected = True
             fake_indicators.append("Suspiciously low market value")
             analysis_sections['pricing'].append({
@@ -488,9 +488,9 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                 'recommendation': 'Provide realistic market value'
             })
         
-        # Check for unrealistic property sizes
+        # Check for unrealistic property sizes - Much more lenient
         square_feet = safe_float_convert(data.get('sq_ft', 0))
-        if square_feet <= 10:  # Extremely small
+        if square_feet <= 5:  # Extremely small - only for obvious fake data
             fake_data_detected = True
             fake_indicators.append("Unrealistic property size")
             analysis_sections['specifications'].append({
@@ -502,7 +502,7 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                 'recommendation': 'Provide realistic property size'
             })
         
-        # Check for repeated suspicious numbers
+        # Check for repeated suspicious numbers - Much more lenient
         all_values = [
             str(data.get('bedrooms', '')),
             str(data.get('bathrooms', '')),
@@ -514,9 +514,9 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
         ]
         
         numeric_values = [v for v in all_values if v.isdigit()]
-        if len(numeric_values) >= 3:
+        if len(numeric_values) >= 5:  # Increased threshold from 3 to 5
             unique_values = set(numeric_values)
-            if len(unique_values) <= 2:  # Most values are the same
+            if len(unique_values) <= 1:  # Only if ALL values are the same
                 fake_data_detected = True
                 fake_indicators.append("Multiple fields have same suspicious values")
                 analysis_sections['basic_info'].append({
@@ -611,34 +611,34 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                     'recommendation': 'Provide a valid postal code'
                 })
         
-        # Specifications validation - Handle flat data structure
+        # Specifications validation - Handle flat data structure - Much more lenient
         bedrooms = safe_int_convert(data.get('bedrooms', 0))
         bathrooms = safe_float_convert(data.get('bathrooms', 0))
         year_built = safe_int_convert(data.get('year_built', 0))
         
-        # Much stricter validation ranges
-        if bedrooms <= 0 or bedrooms > 20:
+        # Much more lenient validation ranges
+        if bedrooms < 0 or bedrooms > 50:  # Increased range from 20 to 50
             analysis_sections['specifications'].append({
                 'check': 'bedrooms',
-                'status': 'fraudulent' if bedrooms <= 0 else 'suspicious',
+                'status': 'fraudulent' if bedrooms < 0 else 'suspicious',
                 'message': 'Unrealistic number of bedrooms.',
                 'details': f'Bedrooms: {bedrooms}',
-                'severity': 'high' if bedrooms <= 0 else 'medium',
+                'severity': 'high' if bedrooms < 0 else 'medium',
                 'recommendation': 'Provide realistic bedroom count'
             })
         
-        if bathrooms <= 0 or bathrooms > 15:
+        if bathrooms < 0 or bathrooms > 30:  # Increased range from 15 to 30
             analysis_sections['specifications'].append({
                 'check': 'bathrooms',
-                'status': 'fraudulent' if bathrooms <= 0 else 'suspicious',
+                'status': 'fraudulent' if bathrooms < 0 else 'suspicious',
                 'message': 'Unrealistic number of bathrooms.',
                 'details': f'Bathrooms: {bathrooms}',
-                'severity': 'high' if bathrooms <= 0 else 'medium',
+                'severity': 'high' if bathrooms < 0 else 'medium',
                 'recommendation': 'Provide realistic bathroom count'
             })
         
         current_year = datetime.now().year
-        if year_built > current_year or year_built < 1800:
+        if year_built > current_year + 5 or year_built < 1800:  # More lenient future year
             analysis_sections['specifications'].append({
                 'check': 'year_built',
                 'status': 'suspicious',
@@ -648,7 +648,7 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                 'recommendation': 'Provide realistic year built'
             })
         
-        # Pricing validation - Handle flat data structure
+        # Pricing validation - Handle flat data structure - Much more lenient
         if market_value <= 0:
             analysis_sections['pricing'].append({
                 'check': 'market_value',
@@ -658,21 +658,21 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                 'severity': 'high',
                 'recommendation': 'Provide property market value'
             })
-        elif market_value < 100000:  # Minimum reasonable price
+        elif market_value < 10000:  # Much more lenient minimum price
             analysis_sections['pricing'].append({
                 'check': 'market_value',
-                'status': 'fraudulent' if market_value < 10000 else 'suspicious',
+                'status': 'fraudulent' if market_value < 1000 else 'suspicious',
                 'message': 'Unusually low market value.',
                 'details': f'Market value: ₹{market_value:,.0f}',
-                'severity': 'high' if market_value < 10000 else 'medium',
+                'severity': 'high' if market_value < 1000 else 'medium',
                 'recommendation': 'Verify market value is accurate'
             })
         
-        # Description validation
+        # Description validation - Much more lenient
         description = data.get('description', '').strip()
         if description:
-            # Check for fake description patterns
-            if description.isdigit() or description in ['1', '2', '3', '4', '5']:
+            # Check for fake description patterns - Much more lenient
+            if description.isdigit() and len(description) <= 2:  # Only single/double digits
                 fake_data_detected = True
                 fake_indicators.append("Description is just a number")
                 analysis_sections['description'].append({
@@ -683,7 +683,7 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                     'severity': 'high',
                     'recommendation': 'Provide a real property description'
                 })
-            elif len(description) < 50:
+            elif len(description) < 30:  # Reduced from 50 to 30
                 analysis_sections['description'].append({
                     'check': 'description',
                     'status': 'insufficient',

models/fraud_classification.py

@@ -12,53 +12,55 @@ def classify_fraud(property_details, description):
         # Combine property details and description for analysis
         text_to_analyze = f"{property_details} {description}"
         
-        # CRITICAL: Check for obvious fake data patterns first
+        # CRITICAL: Check for obvious fake data patterns first - Much more lenient
         fake_patterns = [
-            r'\b\d+\s*$',  # Numbers at end of lines
-            r'^\d+$',      # Only numbers
-            r'\b\d{1,2}\s*$',  # Single or double digits
-            r'price.*\d{1,3}',  # Very low prices
-            r'size.*\d{1,3}',   # Very small sizes
-            r'bedrooms.*\d{1,2}',  # Very few bedrooms
-            r'bathrooms.*\d{1,2}', # Very few bathrooms
+            r'^\d+$',      # Only numbers (very strict)
+            r'price.*\d{1,2}',  # Very low prices (more lenient)
+            r'size.*\d{1,2}',   # Very small sizes (more lenient)
         ]
         
         fake_detected = False
         for pattern in fake_patterns:
             if re.search(pattern, text_to_analyze.lower()):
-                fake_detected = True
-                break
-        
-        # Check for repeated numbers (like "2, 2, 2, 2")
+                # Only mark as fake if it's extremely obvious
+                if pattern == r'^\d+$' and len(text_to_analyze.strip()) <= 3:
+                    fake_detected = True
+                    break
+                # For other patterns, be more lenient
+                elif pattern in [r'price.*\d{1,2}', r'size.*\d{1,2}']:
+                    # Only mark as fake if multiple patterns are found
+                    continue
+        
+        # Check for repeated numbers (like "2, 2, 2, 2") - Much more lenient
         numbers = re.findall(r'\b\d+\b', text_to_analyze.lower())
-        if len(numbers) >= 3:
+        if len(numbers) >= 5:  # Increased threshold from 3 to 5
             unique_numbers = set(numbers)
-            if len(unique_numbers) <= 2:  # If most numbers are the same
+            if len(unique_numbers) <= 1:  # Only if ALL numbers are the same
                 fake_detected = True
         
-        # Check for extremely low values
-        if any(word in text_to_analyze.lower() for word in ['₹2', '₹1', '₹3', '₹4', '₹5']):
+        # Check for extremely low values - Much more lenient
+        if any(word in text_to_analyze.lower() for word in ['₹1', '₹2']):  # Only extremely low values
             fake_detected = True
         
-        # Check for very small property sizes
-        if any(word in text_to_analyze.lower() for word in ['2 sq ft', '1 sq ft', '3 sq ft', '4 sq ft', '5 sq ft']):
+        # Check for very small property sizes - Much more lenient
+        if any(word in text_to_analyze.lower() for word in ['1 sq ft', '2 sq ft']):  # Only extremely small
             fake_detected = True
         
-        # If fake data is detected, return high fraud score immediately
+        # If fake data is detected, return moderate fraud score instead of high
         if fake_detected:
             return {
-                'alert_level': 'high',
-                'alert_score': 0.9,  # 90% fraud score for fake data
+                'alert_level': 'medium',  # Changed from 'high' to 'medium'
+                'alert_score': 0.6,  # Reduced from 0.9 to 0.6
                 'confidence_scores': {
-                    'high risk listing': 0.9,
-                    'potential fraud': 0.8,
-                    'suspicious listing': 0.7,
-                    'legitimate listing': 0.1
+                    'high risk listing': 0.6,  # Reduced from 0.9
+                    'potential fraud': 0.5,    # Reduced from 0.8
+                    'suspicious listing': 0.4,  # Reduced from 0.7
+                    'legitimate listing': 0.2   # Increased from 0.1
                 },
                 'high_risk': ['Fake data patterns detected'],
                 'medium_risk': [],
                 'low_risk': [],
-                'reasoning': 'This property was classified as high risk due to detected fake data patterns (repeated numbers, suspiciously low values, unrealistic specifications).'
+                'reasoning': 'This property was classified as medium risk due to detected fake data patterns.'
             }
         
         # Use a more lenient classification approach for legitimate-looking data
@@ -85,41 +87,41 @@ def classify_fraud(property_details, description):
             'reasoning': ''
         }
         
-        # Process classification results - More lenient for legitimate data
+        # Process classification results - Much more lenient for legitimate data
         fraud_score = 0.0
         if isinstance(result, dict) and 'scores' in result:
             for label, score in zip(result.get('labels', []), result.get('scores', [])):
                 if label != "legitimate listing":
                     try:
                         score_val = float(score)
-                        # Reduce the impact of suspicious classifications
+                        # Much more lenient reduction of suspicious classifications
                         if label == "suspicious listing":
-                            score_val *= 0.5  # Reduce suspicious impact by 50%
+                            score_val *= 0.3  # Reduced from 0.5 to 0.3
                         elif label == "potential fraud":
-                            score_val *= 0.7  # Reduce potential fraud impact by 30%
+                            score_val *= 0.5  # Reduced from 0.7 to 0.5
                         elif label == "high risk listing":
-                            score_val *= 0.8  # Reduce high risk impact by 20%
+                            score_val *= 0.6  # Reduced from 0.8 to 0.6
                     except Exception:
                         score_val = 0.0
                     fraud_score += score_val
                     fraud_classification['confidence_scores'][label] = score_val
         else:
             # Handle fallback result
-            fraud_score = 0.05  # Reduced from 0.1 to 0.05
+            fraud_score = 0.02  # Reduced from 0.05 to 0.02
 
-        # Normalize fraud score to 0-1 range with more lenient scaling
+        # Normalize fraud score to 0-1 range with much more lenient scaling
         try:
-            fraud_score = min(1.0, fraud_score / (len(risk_categories) - 1) * 0.7)  # Reduced by 30%
+            fraud_score = min(1.0, fraud_score / (len(risk_categories) - 1) * 0.5)  # Reduced by 50%
         except Exception:
             fraud_score = 0.0
         fraud_classification['alert_score'] = fraud_score
         
-        # Determine alert level with more lenient thresholds
-        if fraud_score >= 0.7:  # Increased from 0.6
+        # Determine alert level with much more lenient thresholds
+        if fraud_score >= 0.8:  # Increased from 0.7
             fraud_classification['alert_level'] = 'high'
-        elif fraud_score >= 0.4:  # Increased from 0.3
+        elif fraud_score >= 0.5:  # Increased from 0.4
             fraud_classification['alert_level'] = 'medium'
-        elif fraud_score >= 0.2:  # Increased from 0.1
+        elif fraud_score >= 0.3:  # Increased from 0.2
             fraud_classification['alert_level'] = 'low'
         else:
             fraud_classification['alert_level'] = 'minimal'
@@ -127,11 +129,11 @@ def classify_fraud(property_details, description):
         # Generate reasoning based on scores
         reasoning_parts = []
         
-        if fraud_score < 0.2:
+        if fraud_score < 0.3:
             reasoning_parts.append("This property was classified as legitimate based on AI analysis of the listing details.")
-        elif fraud_score < 0.4:
+        elif fraud_score < 0.5:
             reasoning_parts.append("This property was classified as low risk based on AI analysis of the listing details.")
-        elif fraud_score < 0.7:
+        elif fraud_score < 0.8:
             reasoning_parts.append("This property was classified as medium risk based on AI analysis of the listing details.")
         else:
             reasoning_parts.append("This property was classified as high risk based on AI analysis of the listing details.")
@@ -139,7 +141,7 @@ def classify_fraud(property_details, description):
         # Add specific risk indicators if any
         if fraud_classification['confidence_scores']:
             highest_risk = max(fraud_classification['confidence_scores'].items(), key=lambda x: x[1])
-            if highest_risk[1] > 0.3:
+            if highest_risk[1] > 0.4:  # Increased threshold from 0.3 to 0.4
                 reasoning_parts.append(f"Primary concern: {highest_risk[0]} (confidence: {highest_risk[1]:.0%})")
         
         fraud_classification['reasoning'] = " ".join(reasoning_parts)
@@ -150,7 +152,7 @@ def classify_fraud(property_details, description):
         logger.error(f"Error in fraud classification: {str(e)}")
         return {
             'alert_level': 'minimal',
-            'alert_score': 0.05,  # Reduced from 0.1
+            'alert_score': 0.02,  # Reduced from 0.05 to 0.02
             'confidence_scores': {},
             'high_risk': [],
             'medium_risk': [],

models/location_analysis.py

@@ -15,39 +15,38 @@ def validate_address_format(address: str) -> bool:
     if not address:
         return False
     
-    # Check for minimum length
-    if len(address.strip()) < 10:  # Minimum reasonable length for an address
+    # Much more lenient minimum length
+    if len(address.strip()) < 5:  # Reduced from 10 to 5
         return False
     
-    # Check for minimum components
+    # Much more lenient component check
     components = [comp.strip() for comp in address.split(',')]
-    if len(components) < 2:  # At least area and city
+    if len(components) < 1:  # Reduced from 2 to 1 - just need some address
         return False
     
-    # Check for common address patterns
+    # Much more lenient pattern matching
     patterns = [
-        r'\d+',  # Should contain numbers
-        r'[A-Za-z\s]+',  # Should contain letters
-        r'(?:street|road|avenue|lane|colony|society|apartment|flat|house|building|plot|block|sector|phase|floor|wing|area|locality|main|cross|circle|square|market|ward|zone|mandal|municipal|corporation|greater)',  # Common address terms
+        r'[A-Za-z\s]+',  # Should contain letters (most important)
     ]
     
-    # Check if at least 2 patterns match
+    # Check if at least 1 pattern matches (reduced from 2)
     pattern_matches = sum(1 for pattern in patterns if re.search(pattern, address.lower()))
-    if pattern_matches < 2:
+    if pattern_matches < 1:  # Reduced from 2 to 1
         return False
     
-    # Check for common address components
+    # Much more lenient address component check
     address_lower = address.lower()
     has_location = any(term in address_lower for term in [
         'ward', 'zone', 'mandal', 'municipal', 'corporation', 'greater',
-        'street', 'road', 'avenue', 'lane', 'colony', 'society'
+        'street', 'road', 'avenue', 'lane', 'colony', 'society', 'area', 'near'
     ])
     has_area = any(term in address_lower for term in [
         'colony', 'society', 'apartment', 'flat', 'house', 'plot', 'block', 'sector',
-        'area', 'locality', 'main', 'cross', 'circle', 'square', 'market'
+        'area', 'locality', 'main', 'cross', 'circle', 'square', 'market', 'near'
     ])
     
-    return has_location or has_area
+    # Much more lenient - return True if either condition is met or if address has reasonable length
+    return has_location or has_area or len(address.strip()) >= 8  # Added length-based validation
 
 def validate_postal_code(postal_code: str) -> bool:
     """Validate Indian postal code format."""
@@ -57,13 +56,13 @@ def validate_postal_code(postal_code: str) -> bool:
     # Remove any spaces and convert to string
     postal_code = str(postal_code).strip().replace(' ', '')
     
-    # Check format
-    if not re.match(r'^\d{6}$', postal_code):
+    # Much more lenient format check
+    if not re.match(r'^\d{5,6}$', postal_code):  # Allow 5-6 digits instead of exactly 6
         return False
     
-    # Validate first digit (region)
+    # Much more lenient first digit validation
     first_digit = int(postal_code[0])
-    if first_digit not in range(1, 9):  # India has 8 postal regions
+    if first_digit not in range(0, 10):  # Allow 0-9 instead of 1-8
         return False
     
     return True
@@ -75,12 +74,12 @@ def validate_coordinates(latitude: str, longitude: str) -> bool:
         lat = float(str(latitude).strip())
         lng = float(str(longitude).strip())
         
-        # India's approximate boundaries with some buffer
+        # Much more lenient India boundaries with larger buffer
         india_bounds = {
-            'lat_min': 6.0,  # Slightly expanded for coastal areas
-            'lat_max': 38.0,  # Slightly expanded for northern regions
-            'lng_min': 67.0,  # Slightly expanded for western regions
-            'lng_max': 98.0   # Slightly expanded for eastern regions
+            'lat_min': 5.0,   # Reduced from 6.0
+            'lat_max': 40.0,  # Increased from 38.0
+            'lng_min': 65.0,  # Reduced from 67.0
+            'lng_max': 100.0  # Increased from 98.0
         }
         
         # Check if coordinates are within India's boundaries
@@ -88,12 +87,12 @@ def validate_coordinates(latitude: str, longitude: str) -> bool:
                 india_bounds['lng_min'] <= lng <= india_bounds['lng_max']):
             return False
         
-        # Check for reasonable precision (no more than 6 decimal places)
-        lat_str = f"{lat:.6f}"
-        lng_str = f"{lng:.6f}"
+        # Much more lenient precision check
+        lat_str = f"{lat:.4f}"  # Reduced from 6 to 4 decimal places
+        lng_str = f"{lng:.4f}"  # Reduced from 6 to 4 decimal places
         
-        # Check if the original values match the formatted values
-        if abs(float(lat_str) - lat) > 0.000001 or abs(float(lng_str) - lng) > 0.000001:
+        # Much more lenient precision validation
+        if abs(float(lat_str) - lat) > 0.0001 or abs(float(lng_str) - lng) > 0.0001:  # Increased tolerance
             return False
         
         return True
@@ -376,28 +375,31 @@ def analyze_location(data: Dict[str, Any]) -> Dict[str, Any]:
                 data.get('city', '')
             )
         }
-        # Calculate weighted completeness score with adjusted weights
+        # Calculate weighted completeness score with much more lenient weights
         weights = {
-            'address_format_valid': 0.15,
-            'address_in_city': 0.20,  # Increased weight for address verification
-            'city_in_state': 0.10,
-            'state_in_country': 0.10,
-            'postal_code_valid': 0.10,
-            'postal_code_in_city': 0.10,
-            'coordinates_valid': 0.10,
-            'coordinates_in_city': 0.15
+            'address_format_valid': 0.10,  # Reduced from 0.15
+            'address_in_city': 0.15,       # Reduced from 0.20
+            'city_in_state': 0.15,         # Increased from 0.10
+            'state_in_country': 0.15,      # Increased from 0.10
+            'postal_code_valid': 0.15,     # Increased from 0.10
+            'postal_code_in_city': 0.10,   # Keep same
+            'coordinates_valid': 0.10,     # Keep same
+            'coordinates_in_city': 0.10    # Reduced from 0.15
         }
         completeness_score = sum(
             weights[key] * 100 if result else 0 
             for key, result in verification_results.items()
         )
-        # Determine location quality with more lenient criteria
-        critical_checks = ['address_format_valid', 'city_in_state', 'state_in_country', 'postal_code_valid']
-        secondary_checks = ['address_in_city', 'postal_code_in_city', 'coordinates_valid', 'coordinates_in_city']
-        # Location is verified if all critical checks pass and at least 2 secondary checks pass
+        
+        # Much more lenient criteria for location quality
+        critical_checks = ['city_in_state', 'state_in_country']  # Reduced critical checks
+        secondary_checks = ['address_format_valid', 'address_in_city', 'postal_code_valid', 'postal_code_in_city', 'coordinates_valid', 'coordinates_in_city']
+        
+        # Location is verified if critical checks pass and at least 1 secondary check passes
         critical_passed = all(verification_results[check] for check in critical_checks)
         secondary_passed = sum(1 for check in secondary_checks if verification_results[check])
-        location_quality = "verified" if critical_passed and secondary_passed >= 2 else "unverified"
+        location_quality = "verified" if critical_passed and secondary_passed >= 1 else "unverified"  # Reduced from 2 to 1
+        
         # Analyze landmarks
         landmarks_analysis = {
             'provided': bool(data.get('nearby_landmarks')),
@@ -419,6 +421,7 @@ def analyze_location(data: Dict[str, Any]) -> Dict[str, Any]:
                     if any(keyword in landmark for keyword in keywords):
                         if type_name not in landmarks_analysis['types']:
                             landmarks_analysis['types'].append(type_name)
+        
         # Determine city tier
         city_tier = "unknown"
         if data.get('city'):
@@ -433,9 +436,22 @@ def analyze_location(data: Dict[str, Any]) -> Dict[str, Any]:
                 city_tier = "tier2"
             else:
                 city_tier = "tier3"
+        
+        # Much more lenient assessment criteria
+        if completeness_score >= 60:  # Reduced from 80
+            assessment = "complete"
+        elif completeness_score >= 30:  # Reduced from 50
+            assessment = "partial"
+        else:
+            assessment = "minimal"
+        
+        # Ensure minimum score for valid data
+        if completeness_score == 0 and (data.get('city') or data.get('state')):
+            completeness_score = 40  # Minimum 40% for having city/state
+        
         return {
             **verification_results,
-            'assessment': "complete" if completeness_score >= 80 else "partial" if completeness_score >= 50 else "minimal",
+            'assessment': assessment,
             'completeness_score': completeness_score,
             'location_quality': location_quality,
             'city_tier': city_tier,
@@ -447,7 +463,7 @@ def analyze_location(data: Dict[str, Any]) -> Dict[str, Any]:
         logger.error(f"Error analyzing location: {str(e)}")
         return {
             'assessment': 'error',
-            'completeness_score': 0,
+            'completeness_score': 30,  # Increased from 0 to 30
             'location_quality': 'error',
             'city_tier': 'unknown',
             'landmarks_analysis': {'provided': False, 'count': 0, 'types': []},

models/price_analysis.py

@@ -550,50 +550,50 @@ def analyze_price(data, context_text=None, latitude=None, longitude=None, proper
         else:
             deviation = 0
         
-        # Determine assessment based on deviation and price reasonableness
-        if price_per_sqft < 100:  # Extremely low price
+        # Determine assessment based on deviation and price reasonableness - Much more lenient
+        if price_per_sqft < 50:  # Extremely low price - increased from 100
             assessment = "suspicious_pricing"
-            confidence = 0.1
-        elif price_per_sqft < market_avg * 0.3:  # Very below market
+            confidence = 0.2  # Increased from 0.1
+        elif price_per_sqft < market_avg * 0.2:  # Very below market - reduced from 0.3
             assessment = "below_market"
-            confidence = 0.3
-        elif price_per_sqft < market_avg * 0.7:  # Below market
+            confidence = 0.4  # Increased from 0.3
+        elif price_per_sqft < market_avg * 0.6:  # Below market - reduced from 0.7
             assessment = "below_market"
-            confidence = 0.6
-        elif price_per_sqft <= market_avg * 1.3:  # Market rate
+            confidence = 0.7  # Increased from 0.6
+        elif price_per_sqft <= market_avg * 1.5:  # Market rate - increased from 1.3
             assessment = "market_rate"
-            confidence = 0.8
-        elif price_per_sqft <= market_avg * 2.0:  # Above market
+            confidence = 0.9  # Increased from 0.8
+        elif price_per_sqft <= market_avg * 2.5:  # Above market - increased from 2.0
             assessment = "above_market"
-            confidence = 0.7
+            confidence = 0.8  # Increased from 0.7
         else:  # Very above market
             assessment = "premium_pricing"
-            confidence = 0.5
+            confidence = 0.6  # Increased from 0.5
         
-        # Generate risk indicators
+        # Generate risk indicators - Much more lenient
         risk_indicators = []
-        if price_per_sqft < 100:
+        if price_per_sqft < 50:  # Increased from 100
             risk_indicators.append("⚠️ Property priced extremely low (suspicious)")
-        elif price_per_sqft < market_avg * 0.3:
+        elif price_per_sqft < market_avg * 0.2:  # Reduced from 0.3
             risk_indicators.append("⚠️ Property priced significantly below market average")
-        elif price_per_sqft > market_avg * 2.0:
+        elif price_per_sqft > market_avg * 2.5:  # Increased from 2.0
             risk_indicators.append("⚠️ Property priced significantly above market average")
         
-        # Price ranges for the city
+        # Price ranges for the city - Much more lenient
         price_ranges = {
             'budget': {
-                'min': market_avg * 0.5,
+                'min': market_avg * 0.3,  # Reduced from 0.5
                 'max': market_avg * 0.8,
                 'description': f'Budget properties in {city}'
             },
             'mid_range': {
                 'min': market_avg * 0.8,
-                'max': market_avg * 1.2,
+                'max': market_avg * 1.4,  # Increased from 1.2
                 'description': f'Mid-range properties in {city}'
             },
             'premium': {
-                'min': market_avg * 1.2,
-                'max': market_avg * 2.0,
+                'min': market_avg * 1.4,  # Reduced from 1.2
+                'max': market_avg * 2.5,  # Increased from 2.0
                 'description': f'Premium properties in {city}'
             }
         }

models/trust_score.py

@@ -6,60 +6,63 @@ import re
 
 def generate_trust_score(text, image_analysis, pdf_analysis):
     try:
-        # Start with a more reasonable base score
-        trust_score = 30.0  # Increased from 20.0 to give more reasonable starting point
+        # Start with a much higher base score for legitimate properties
+        trust_score = 50.0  # Increased from 30.0 to 50.0 to give more reasonable starting point
         reasoning_parts = []
 
         # Simple text-based trust indicators
         text_lower = str(text).lower()
         
-        # CRITICAL: Check for obvious fake data patterns - but be less punitive
+        # CRITICAL: Check for obvious fake data patterns - but be much less punitive
         fake_patterns = [
-            r'\b\d+\s*$',  # Numbers at end of lines
-            r'^\d+$',      # Only numbers
-            r'\b\d{1,2}\s*$',  # Single or double digits
-            r'price.*\d{1,3}',  # Very low prices
-            r'size.*\d{1,3}',   # Very small sizes
-            r'bedrooms.*\d{1,2}',  # Very few bedrooms
-            r'bathrooms.*\d{1,2}', # Very few bathrooms
+            r'^\d+$',      # Only numbers (very strict)
+            r'price.*\d{1,2}',  # Very low prices (more lenient)
+            r'size.*\d{1,2}',   # Very small sizes (more lenient)
         ]
         
         fake_detected = False
         for pattern in fake_patterns:
             if re.search(pattern, text_lower):
-                fake_detected = True
-                trust_score -= 15  # Reduced penalty from 30 to 15
-                reasoning_parts.append("Detected suspicious number patterns")
-                break
-        
-        # Check for repeated numbers (like "2, 2, 2, 2") - but be less punitive
+                # Only mark as fake if it's extremely obvious
+                if pattern == r'^\d+$' and len(text.strip()) <= 3:
+                    fake_detected = True
+                    trust_score -= 10  # Reduced penalty from 15 to 10
+                    reasoning_parts.append("Detected suspicious number patterns")
+                    break
+                # For other patterns, be more lenient
+                elif pattern in [r'price.*\d{1,2}', r'size.*\d{1,2}']:
+                    # Only mark as fake if multiple patterns are found
+                    continue
+        
+        # Check for repeated numbers (like "2, 2, 2, 2") - but be much less punitive
         numbers = re.findall(r'\b\d+\b', text_lower)
-        if len(numbers) >= 3:
+        if len(numbers) >= 5:  # Increased threshold from 3 to 5
             unique_numbers = set(numbers)
-            if len(unique_numbers) <= 2:  # If most numbers are the same
+            if len(unique_numbers) <= 1:  # Only if ALL numbers are the same
                 fake_detected = True
-                trust_score -= 20  # Reduced penalty from 40 to 20
+                trust_score -= 15  # Reduced penalty from 20 to 15
                 reasoning_parts.append("Detected repeated number patterns (likely fake data)")
         
-        # Check for extremely low values - but be less punitive
-        if any(word in text_lower for word in ['₹2', '₹1', '₹3', '₹4', '₹5']):
+        # Check for extremely low values - but be much less punitive
+        if any(word in text_lower for word in ['₹1', '₹2']):  # Only extremely low values
             fake_detected = True
-            trust_score -= 25  # Reduced penalty from 50 to 25
+            trust_score -= 20  # Reduced penalty from 25 to 20
             reasoning_parts.append("Detected suspiciously low pricing")
         
-        # Check for very small property sizes - but be less punitive
-        if any(word in text_lower for word in ['2 sq', '1 sq', '3 sq', '4 sq', '5 sq']):
+        # Check for very small property sizes - but be much less punitive
+        if any(word in text_lower for word in ['1 sq', '2 sq']):  # Only extremely small
             fake_detected = True
-            trust_score -= 20  # Reduced penalty from 40 to 20
+            trust_score -= 15  # Reduced penalty from 20 to 15
             reasoning_parts.append("Detected suspiciously small property size")
 
-        # Positive trust indicators - More generous
+        # Positive trust indicators - Much more generous
         positive_indicators = [
             'apartment', 'flat', 'house', 'villa', 'bungalow', 'property', 'real estate',
             'bedroom', 'bathroom', 'kitchen', 'living', 'dining', 'balcony', 'parking',
             'amenities', 'facilities', 'security', 'lift', 'gym', 'pool', 'garden',
             'hyderabad', 'mumbai', 'delhi', 'bangalore', 'chennai', 'kolkata', 'pune',
-            'verified', 'authentic', 'genuine', 'legitimate', 'original', 'certified'
+            'verified', 'authentic', 'genuine', 'legitimate', 'original', 'certified',
+            'pg', 'hostel', 'office', 'commercial', 'retail', 'warehouse', 'industrial'
         ]
         
         negative_indicators = [
@@ -70,82 +73,82 @@ def generate_trust_score(text, image_analysis, pdf_analysis):
         positive_count = sum(1 for indicator in positive_indicators if indicator in text_lower)
         negative_count = sum(1 for indicator in negative_indicators if indicator in text_lower)
         
-        # Adjust score based on indicators - More balanced
+        # Adjust score based on indicators - Much more balanced
         if positive_count > 0 and not fake_detected:
-            trust_score += min(20, positive_count * 3)  # Increased from 15 to 20
+            trust_score += min(25, positive_count * 4)  # Increased from 20 to 25
             reasoning_parts.append(f"Found {positive_count} positive trust indicators")
         
         if negative_count > 0:
-            trust_score -= min(25, negative_count * 5)  # Reduced penalty from 30 to 25
+            trust_score -= min(20, negative_count * 4)  # Reduced penalty from 25 to 20
             reasoning_parts.append(f"Found {negative_count} negative trust indicators")
         
-        # Image analysis contribution - More balanced
+        # Image analysis contribution - Much more balanced
         if image_analysis:
             image_count = len(image_analysis) if isinstance(image_analysis, list) else 1
             if image_count > 0:
                 # Check if images are actually property-related
                 property_related_count = sum(1 for img in image_analysis if img.get('is_property_related', False))
                 if property_related_count > 0:
-                    trust_score += min(15, property_related_count * 4)  # Increased from 10 to 15
+                    trust_score += min(20, property_related_count * 5)  # Increased from 15 to 20
                     reasoning_parts.append(f"Property has {property_related_count} property-related images")
                 else:
-                    trust_score -= 15  # Reduced penalty from 20 to 15
+                    trust_score -= 10  # Reduced penalty from 15 to 10
                     reasoning_parts.append("No property-related images detected")
                 
                 # Bonus for multiple high-quality images
                 if property_related_count >= 3:
-                    trust_score += 8  # Increased from 5 to 8
+                    trust_score += 12  # Increased from 8 to 12
                     reasoning_parts.append("Multiple property images provided")
         
-        # PDF analysis contribution - More balanced
+        # PDF analysis contribution - Much more balanced
         if pdf_analysis:
             pdf_count = len(pdf_analysis) if isinstance(pdf_analysis, list) else 1
             if pdf_count > 0:
                 # Check if documents are actually property-related
                 property_related_docs = sum(1 for doc in pdf_analysis if doc.get('is_property_related', False))
                 if property_related_docs > 0:
-                    trust_score += min(15, property_related_docs * 5)  # Increased from 10 to 15
+                    trust_score += min(20, property_related_docs * 6)  # Increased from 15 to 20
                     reasoning_parts.append(f"Property has {property_related_docs} property-related documents")
                 else:
-                    trust_score -= 10  # Reduced penalty from 15 to 10
+                    trust_score -= 8  # Reduced penalty from 10 to 8
                     reasoning_parts.append("No property-related documents detected")
                 
                 # Bonus for multiple documents
                 if property_related_docs >= 2:
-                    trust_score += 5  # Increased from 3 to 5
+                    trust_score += 8  # Increased from 5 to 8
                     reasoning_parts.append("Multiple supporting documents provided")
         
-        # Text quality assessment - More balanced
+        # Text quality assessment - Much more balanced
         if text and len(text) > 200 and not fake_detected:
-            trust_score += 12  # Increased from 8 to 12
+            trust_score += 15  # Increased from 12 to 15
             reasoning_parts.append("Detailed property description provided")
         elif text and len(text) > 100 and not fake_detected:
-            trust_score += 8  # Increased from 4 to 8
+            trust_score += 10  # Increased from 8 to 10
             reasoning_parts.append("Adequate property description provided")
         elif len(text) < 50:
-            trust_score -= 15  # Reduced penalty from 20 to 15
+            trust_score -= 10  # Reduced penalty from 15 to 10
             reasoning_parts.append("Very short property description")
         
-        # Location quality assessment - More balanced
+        # Location quality assessment - Much more balanced
         if 'hyderabad' in text_lower or 'mumbai' in text_lower or 'delhi' in text_lower or 'bangalore' in text_lower:
             if not fake_detected:
-                trust_score += 5  # Increased from 3 to 5
+                trust_score += 8  # Increased from 5 to 8
                 reasoning_parts.append("Property in major city")
         
-        # Property type assessment - More balanced
-        if any(prop_type in text_lower for prop_type in ['apartment', 'flat', 'house', 'villa', 'bungalow']):
+        # Property type assessment - Much more balanced
+        if any(prop_type in text_lower for prop_type in ['apartment', 'flat', 'house', 'villa', 'bungalow', 'pg', 'office']):
             if not fake_detected:
-                trust_score += 4  # Increased from 2 to 4
+                trust_score += 6  # Increased from 4 to 6
                 reasoning_parts.append("Clear property type mentioned")
         
-        # Amenities assessment - More balanced
+        # Amenities assessment - Much more balanced
         amenities_count = sum(1 for amenity in ['pool', 'gym', 'garden', 'parking', 'security', 'lift', 'balcony'] 
                              if amenity in text_lower)
         if amenities_count > 0 and not fake_detected:
-            trust_score += min(8, amenities_count * 2)  # Increased from 5 to 8
+            trust_score += min(12, amenities_count * 3)  # Increased from 8 to 12
             reasoning_parts.append(f"Property has {amenities_count} amenities mentioned")
         
-        # CRITICAL: Additional fake data checks - but be less punitive
+        # CRITICAL: Additional fake data checks - but be much less punitive
         # Check if all major fields are just numbers
         numeric_fields = ['property_name', 'bedrooms', 'bathrooms', 'sq_ft', 'market_value']
         numeric_count = 0
@@ -153,14 +156,14 @@ def generate_trust_score(text, image_analysis, pdf_analysis):
             if field in text_lower and re.search(r'\b\d{1,2}\b', text_lower):
                 numeric_count += 1
         
-        if numeric_count >= 3:  # If 3+ fields are just numbers
+        if numeric_count >= 4:  # Increased threshold from 3 to 4
             fake_detected = True
-            trust_score -= 30  # Reduced penalty from 60 to 30
+            trust_score -= 25  # Reduced penalty from 30 to 25
             reasoning_parts.append("Multiple fields contain only numbers (highly suspicious)")
         
         # Ensure minimum score for any valid data
-        if trust_score < 10 and (image_analysis or pdf_analysis):
-            trust_score = 10  # Minimum score if there are images or documents
+        if trust_score < 20 and (image_analysis or pdf_analysis):
+            trust_score = 20  # Increased minimum score from 10 to 20
         
         # Ensure score is within bounds
         trust_score = max(0, min(100, trust_score))
@@ -175,4 +178,4 @@ def generate_trust_score(text, image_analysis, pdf_analysis):
         
     except Exception as e:
         logger.error(f"Error in trust score generation: {str(e)}")
-        return 20.0, f"Trust analysis failed: {str(e)}"  # Increased from 10.0 to 20.0
+        return 35.0, f"Trust analysis failed: {str(e)}"  # Increased from 20.0 to 35.0