Upload 21 files

models/address_verification.py

@@ -139,7 +139,9 @@ def verify_address(data):
         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
+        # Ensure verification score is properly capped at 100%
+        verification_score = min(100.0, verification_points * 100)  # Convert to percentage and cap at 100%
+        address_results['verification_score'] = verification_score
 
         return address_results
     except Exception as e:

models/cross_validation.py

@@ -539,16 +539,25 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                 'recommendation': 'Provide a valid property name (not just numbers)'
             })
         
-        # Property type validation
+        # Property type validation - Much stricter
         property_type = data.get('property_type', '').strip()
-        if not property_type:
+        if not property_type or property_type.lower() in ['unknown', 'none', 'null', '']:
             analysis_sections['basic_info'].append({
                 'check': 'property_type',
-                'status': 'missing',
-                'message': 'Property type is required.',
-                'details': 'Please specify the property type.',
+                'status': 'suspicious',  # Changed from 'missing' to 'suspicious'
+                'message': 'Property type is unclear or missing.',
+                'details': f'Property type: {property_type}',
                 'severity': 'high' if fake_data_detected else 'medium',
-                'recommendation': 'Specify property type (apartment, house, etc.)'
+                'recommendation': 'Specify clear property type (apartment, house, villa, etc.)'
+            })
+        elif property_type.lower() in ['unknown', 'none', 'null']:
+            analysis_sections['basic_info'].append({
+                'check': 'property_type',
+                'status': 'suspicious',
+                'message': 'Property type is marked as unknown.',
+                'details': f'Property type: {property_type}',
+                'severity': 'medium',
+                'recommendation': 'Provide a specific property type instead of "unknown"'
             })
         
         # Status validation
@@ -615,8 +624,9 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
         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))
+        square_feet = safe_float_convert(data.get('sq_ft', 0))
         
-        # Much more lenient validation ranges
+        # Much more lenient validation ranges, but stricter for 0 values
         if bedrooms < 0 or bedrooms > 50:  # Increased range from 20 to 50
             analysis_sections['specifications'].append({
                 'check': 'bedrooms',
@@ -626,6 +636,15 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                 'severity': 'high' if bedrooms < 0 else 'medium',
                 'recommendation': 'Provide realistic bedroom count'
             })
+        elif bedrooms == 0 and square_feet > 200:  # Suspicious if 0 bedrooms but large property
+            analysis_sections['specifications'].append({
+                'check': 'bedrooms',
+                'status': 'suspicious',
+                'message': 'No bedrooms specified for a large property.',
+                'details': f'Bedrooms: {bedrooms}, Square feet: {square_feet}',
+                'severity': 'medium',
+                'recommendation': 'Specify bedroom count for this property size'
+            })
         
         if bathrooms < 0 or bathrooms > 30:  # Increased range from 15 to 30
             analysis_sections['specifications'].append({
@@ -636,6 +655,15 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                 'severity': 'high' if bathrooms < 0 else 'medium',
                 'recommendation': 'Provide realistic bathroom count'
             })
+        elif bathrooms == 0 and square_feet > 100:  # Suspicious if 0 bathrooms but significant property
+            analysis_sections['specifications'].append({
+                'check': 'bathrooms',
+                'status': 'suspicious',
+                'message': 'No bathrooms specified for this property size.',
+                'details': f'Bathrooms: {bathrooms}, Square feet: {square_feet}',
+                'severity': 'medium',
+                'recommendation': 'Specify bathroom count for this property size'
+            })
         
         current_year = datetime.now().year
         if year_built > current_year + 5 or year_built < 1800:  # More lenient future year
@@ -648,7 +676,7 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                 'recommendation': 'Provide realistic year built'
             })
         
-        # Pricing validation - Handle flat data structure - Much more lenient
+        # Pricing validation - Handle flat data structure - Much more lenient and context-aware
         if market_value <= 0:
             analysis_sections['pricing'].append({
                 'check': 'market_value',
@@ -658,15 +686,56 @@ def perform_cross_validation(data: Dict[str, Any]) -> List[Dict[str, Any]]:
                 'severity': 'high',
                 'recommendation': 'Provide property market value'
             })
-        elif market_value < 10000:  # Much more lenient minimum price
-            analysis_sections['pricing'].append({
-                'check': 'market_value',
-                '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 < 1000 else 'medium',
-                'recommendation': 'Verify market value is accurate'
-            })
+        else:
+            # Context-aware pricing validation
+            square_feet = safe_float_convert(data.get('sq_ft', 0))
+            property_type = data.get('property_type', '').lower()
+            is_rental = data.get('is_rental', False)
+            
+            # Calculate price per sq ft
+            price_per_sqft = market_value / square_feet if square_feet > 0 else 0
+            
+            # Different thresholds based on property type and rental status
+            if is_rental:
+                # Rental properties - monthly rates
+                if price_per_sqft < 5:  # Very low rental rate
+                    analysis_sections['pricing'].append({
+                        'check': 'market_value',
+                        'status': 'suspicious',
+                        'message': 'Unusually low rental rate.',
+                        'details': f'Rental rate: ₹{price_per_sqft:.2f}/sq ft/month',
+                        'severity': 'medium',
+                        'recommendation': 'Verify rental rate is accurate'
+                    })
+                elif price_per_sqft > 100:  # Very high rental rate
+                    analysis_sections['pricing'].append({
+                        'check': 'market_value',
+                        'status': 'suspicious',
+                        'message': 'Unusually high rental rate.',
+                        'details': f'Rental rate: ₹{price_per_sqft:.2f}/sq ft/month',
+                        'severity': 'medium',
+                        'recommendation': 'Verify rental rate is accurate'
+                    })
+            else:
+                # Purchase properties
+                if price_per_sqft < 1000:  # Very low purchase price
+                    analysis_sections['pricing'].append({
+                        'check': 'market_value',
+                        'status': 'suspicious',
+                        'message': 'Unusually low purchase price.',
+                        'details': f'Price per sq ft: ₹{price_per_sqft:.2f}',
+                        'severity': 'medium',
+                        'recommendation': 'Verify purchase price is accurate'
+                    })
+                elif price_per_sqft > 50000:  # Very high purchase price
+                    analysis_sections['pricing'].append({
+                        'check': 'market_value',
+                        'status': 'suspicious',
+                        'message': 'Unusually high purchase price.',
+                        'details': f'Price per sq ft: ₹{price_per_sqft:.2f}',
+                        'severity': 'medium',
+                        'recommendation': 'Verify purchase price is accurate'
+                    })
         
         # Description validation - Much more lenient
         description = data.get('description', '').strip()

models/text_quality.py

@@ -35,19 +35,19 @@ def assess_text_quality(text):
             classifier = load_model("zero-shot-classification")  # Use standard model instead of typeform
         except Exception as e:
             logger.error(f"Error loading model in text quality: {str(e)}")
-            # Fallback scoring for when model fails
+            # Much more lenient fallback scoring for when model fails
             text_length = len(text)
             if text_length > 200:
-                fallback_score = 60
+                fallback_score = 70  # Increased from 60
                 assessment = 'good'
             elif text_length > 100:
-                fallback_score = 40
+                fallback_score = 50  # Increased from 40
                 assessment = 'adequate'
             elif text_length > 50:
-                fallback_score = 25
+                fallback_score = 35  # Increased from 25
                 assessment = 'basic'
             else:
-                fallback_score = 15
+                fallback_score = 25  # Increased from 15
                 assessment = 'basic'
             
             return {
@@ -100,16 +100,16 @@ def assess_text_quality(text):
         
         # Calculate final score (0-100) with better handling of edge cases
         base_score = (positive_score - negative_score + 1) * 50
-        quality_score = max(10, min(100, int(base_score)))  # Ensure minimum 10% score
+        quality_score = max(20, min(100, int(base_score)))  # Increased minimum from 10% to 20%
         
-        # Determine assessment
-        if quality_score >= 80:
+        # Much more lenient assessment thresholds
+        if quality_score >= 70:  # Reduced from 80
             assessment = 'excellent'
-        elif quality_score >= 60:
+        elif quality_score >= 50:  # Reduced from 60
             assessment = 'good'
-        elif quality_score >= 40:
+        elif quality_score >= 30:  # Reduced from 40
             assessment = 'adequate'
-        elif quality_score >= 20:
+        elif quality_score >= 20:  # Reduced from 20
             assessment = 'basic'
         else:
             assessment = 'basic'  # Changed from 'very poor' to 'basic'
@@ -138,9 +138,9 @@ def assess_text_quality(text):
 
     except Exception as e:
         logger.error(f"Error in text quality assessment: {str(e)}")
-        # Return reasonable fallback instead of 0
+        # Return much more reasonable fallback instead of 0
         text_length = len(str(text)) if text else 0
-        fallback_score = max(10, min(50, text_length // 2))  # Basic scoring based on length
+        fallback_score = max(25, min(60, text_length // 2 + 20))  # Much more lenient scoring based on length
         
         return {
             'assessment': 'basic',