Address Standardization Failures

class AddressStandardizer:
    """Standardize and match mortgage addresses"""
    
    ABBREVIATIONS = {
        "st": "street", "st.": "street",
        "rd": "road", "rd.": "road",
        "ave": "avenue", "ave.": "avenue",
        "blvd": "boulevard", "blvd.": "boulevard",
        "ln": "lane", "ln.": "lane",
        "dr": "drive", "dr.": "drive",
        "ct": "court", "ct.": "court",
        "pl": "place", "pl.": "place",
        "n": "north", "n.": "north",
        "s": "south", "s.": "south",
        "e": "east", "e.": "east",
        "w": "west", "w.": "west",
        "apt": "apartment", "apt.": "apartment",
        "#": "unit"
    }
    
    UNIT_DESIGNATORS = ["apartment", "apt", "unit", "suite", "ste", "#"]
    
    def standardize(self, address: str) -> dict:
        """Standardize address to USPS format"""
        addr_lower = address.lower().strip()
        
        # Expand abbreviations
        words = addr_lower.split()
        standardized_words = []
        
        for word in words:
            standardized_words.append(
                self.ABBREVIATIONS.get(word, word)
            )
        
        standardized = " ".join(standardized_words)
        
        # Extract components
        return {
            "original": address,
            "standardized": standardized,
            "components": self.parse_components(standardized)
        }
    
    def parse_components(self, address: str) -> dict:
        """Parse address into components"""
        # Extract unit number
        unit = None
        for designator in self.UNIT_DESIGNATORS:
            if designator in address:
                # Extract unit value
                idx = address.find(designator)
                unit_part = address[idx:].split()[1] if len(address[idx:].split()) > 1 else None
                unit = unit_part
                break
        
        # Basic parsing (would use proper parser in production)
        parts = address.split(",")
        
        return {
            "street": parts[0] if parts else None,
            "unit": unit,
            "city": parts[1].strip() if len(parts) > 1 else None,
            "state_zip": parts[2].strip() if len(parts) > 2 else None
        }
    
    def match_addresses(self, addr1: str, addr2: str) -> dict:
        """Check if two addresses match"""
        std1 = self.standardize(addr1)
        std2 = self.standardize(addr2)
        
        # Exact match after standardization
        if std1["standardized"] == std2["standardized"]:
            return {"match": True, "confidence": 1.0}
        
        # Component-level matching
        comp1 = std1["components"]
        comp2 = std2["components"]
        
        # Street number must match exactly
        street1_num = self.extract_street_number(comp1.get("street", ""))
        street2_num = self.extract_street_number(comp2.get("street", ""))
        
        if street1_num != street2_num:
            return {
                "match": False,
                "reason": "Street numbers differ"
            }
        
        # Fuzzy match street name
        similarity = self.string_similarity(
            comp1.get("street", ""),
            comp2.get("street", "")
        )
        
        return {
            "match": similarity > 0.85,
            "confidence": similarity,
            "variations": {
                "addr1": std1["standardized"],
                "addr2": std2["standardized"]
            }
        }
    
    def classify_address_type(self, address: str) -> str:
        """Classify as property, mailing, or PO Box"""
        addr_lower = address.lower()
        
        if "po box" in addr_lower or "p.o. box" in addr_lower:
            return "po_box"
        
        if "rural route" in addr_lower or "rr " in addr_lower:
            return "rural_route"
        
        # Default to physical
        return "physical"
    
    def cross_validate_addresses(self, 
                                 documents: list,
                                 subject_property: str) -> dict:
        """Validate addresses match subject property"""
        std_subject = self.standardize(subject_property)
        mismatches = []
        
        for doc in documents:
            if doc.get("property_address"):
                match = self.match_addresses(
                    subject_property,
                    doc["property_address"]
                )
                
                if not match["match"]:
                    mismatches.append({
                        "document": doc["type"],
                        "address": doc["property_address"],
                        "confidence": match.get("confidence", 0)
                    })
        
        return {
            "subject_property": subject_property,
            "all_match": len(mismatches) == 0,
            "mismatches": mismatches
        }