Address Validation

def addressvalidation(client, addressLines, regionCode=None, locality=None,
                     enableUspsCass=None):
    """
    Validate and standardize postal addresses.
    
    Args:
        client (Client): Google Maps API client instance
        addressLines (list): List of address line strings representing the 
                           unstructured address (e.g., ["1600 Amphitheatre Pkwy", "Mountain View CA"])
        regionCode (str): Region code in CLDR format (e.g., "US", "GB").
                         Helps improve validation accuracy.
        locality (str): Locality/city name to assist in validation when
                       not clear from address lines
        enableUspsCass (bool): Enable USPS CASS validation for US addresses.
                              Provides additional certification and standardization.
    
    Returns:
        dict: Address validation response containing:
              - result: Validation result with standardized address
              - responseId: Unique identifier for this validation request
              Contains verdict, address components, geocoding, and delivery info
    
    Raises:
        googlemaps.exceptions.ApiError: When API returns an error
        googlemaps.exceptions.TransportError: When HTTP request fails
        googlemaps.exceptions.Timeout: When request times out
    """

import googlemaps

gmaps = googlemaps.Client(key='YOUR_API_KEY')

# Validate a US address
address_lines = [
    "1600 Amphitheatre Pkwy",
    "Mountain View CA 94043"
]

validation_result = gmaps.addressvalidation(
    addressLines=address_lines,
    regionCode="US"
)

# Extract validation results
result = validation_result['result']
verdict = result['verdict']

print("Address Validation Results:")
print("=" * 30)

# Overall validation verdict
print(f"Input Granularity: {verdict['inputGranularity']}")
print(f"Validation Granularity: {verdict['validationGranularity']}")
print(f"Geocode Granularity: {verdict['geocodeGranularity']}")

# Address completeness
address_complete = verdict.get('addressComplete', False)
print(f"Address Complete: {address_complete}")

# Check if components were inferred or confirmed
if 'hasUnconfirmedComponents' in verdict:
    print(f"Has Unconfirmed Components: {verdict['hasUnconfirmedComponents']}")

if 'hasInferredComponents' in verdict:
    print(f"Has Inferred Components: {verdict['hasInferredComponents']}")

import googlemaps

gmaps = googlemaps.Client(key='YOUR_API_KEY')

# Validate address and analyze components
address_lines = ["123 Main St", "Anytown NY 12345"]

validation_result = gmaps.addressvalidation(
    addressLines=address_lines,
    regionCode="US",
    enableUspsCass=True  # Enable USPS certification
)

result = validation_result['result']

# Analyze address components
if 'address' in result:
    address_info = result['address']
    
    print("Standardized Address Components:")
    print("=" * 40)
    
    # Formatted address
    if 'formattedAddress' in address_info:
        print(f"Formatted Address: {address_info['formattedAddress']}")
    
    # Individual components
    if 'addressComponents' in address_info:
        for component in address_info['addressComponents']:
            component_name = component['componentName']['text']
            component_type = component['componentType']
            confirmation_level = component.get('confirmationLevel', 'UNKNOWN')
            
            print(f"{component_type}: {component_name} ({confirmation_level})")
    
    # Postal address details
    if 'postalAddress' in address_info:
        postal = address_info['postalAddress']
        print(f"\nPostal Details:")
        print(f"  Region Code: {postal.get('regionCode', 'N/A')}")
        print(f"  Language Code: {postal.get('languageCode', 'N/A')}")
        print(f"  Postal Code: {postal.get('postalCode', 'N/A')}")
        
        if 'addressLines' in postal:
            print(f"  Standardized Lines:")
            for i, line in enumerate(postal['addressLines']):
                print(f"    {i+1}: {line}")

import googlemaps

gmaps = googlemaps.Client(key='YOUR_API_KEY')

# US address with USPS CASS validation enabled
us_address = [
    "1 E Main St",
    "Mesa AZ 85201"
]

usps_validation = gmaps.addressvalidation(
    addressLines=us_address,
    regionCode="US",
    enableUspsCass=True
)

result = usps_validation['result']

print("USPS CASS Validation Results:")
print("=" * 35)

# Check for USPS data
if 'uspsData' in result:
    usps_info = result['uspsData']
    
    print(f"USPS Standardized Address:")
    print(f"  First Address Line: {usps_info.get('standardizedAddress', {}).get('firstAddressLine', 'N/A')}")
    print(f"  City: {usps_info.get('standardizedAddress', {}).get('cityName', 'N/A')}")
    print(f"  State: {usps_info.get('standardizedAddress', {}).get('state', 'N/A')}")
    print(f"  ZIP Code: {usps_info.get('standardizedAddress', {}).get('zipCode', 'N/A')}")
    
    # Delivery point information
    if 'deliveryPointCode' in usps_info:
        print(f"  Delivery Point: {usps_info['deliveryPointCode']}")
    
    if 'deliveryPointCheckDigit' in usps_info:
        print(f"  Check Digit: {usps_info['deliveryPointCheckDigit']}")
    
    # Address record type
    if 'recordType' in usps_info:
        print(f"  Record Type: {usps_info['recordType']}")
    
    # ZIP+4 information
    if 'zipPlusFourCode' in usps_info:
        print(f"  ZIP+4: {usps_info['zipPlusFourCode']}")

# Check delivery information
if 'verdict' in result and 'hasReplacedComponents' in result['verdict']:
    print(f"Components Replaced: {result['verdict']['hasReplacedComponents']}")

import googlemaps

gmaps = googlemaps.Client(key='YOUR_API_KEY')

# Validate international addresses
addresses = [
    {
        'lines': ["10 Downing Street", "London SW1A 2AA"],
        'region': "GB",
        'name': "UK Address"
    },
    {
        'lines': ["1-1 Marunouchi", "Chiyoda City, Tokyo 100-0005"],
        'region': "JP", 
        'name': "Japan Address"
    },
    {
        'lines': ["Champs-Élysées", "Paris 75008"],
        'region': "FR",
        'name': "France Address"
    }
]

for addr_info in addresses:
    print(f"\nValidating {addr_info['name']}:")
    print("-" * 30)
    
    validation = gmaps.addressvalidation(
        addressLines=addr_info['lines'],
        regionCode=addr_info['region']
    )
    
    result = validation['result']
    
    # Display formatted address
    if 'address' in result and 'formattedAddress' in result['address']:
        formatted = result['address']['formattedAddress']
        print(f"Formatted: {formatted}")
    
    # Display validation quality
    if 'verdict' in result:
        verdict = result['verdict']
        granularity = verdict.get('validationGranularity', 'UNKNOWN')
        print(f"Validation Quality: {granularity}")

import googlemaps

gmaps = googlemaps.Client(key='YOUR_API_KEY')

def validate_address_list(addresses):
    """Validate multiple addresses and return results."""
    results = []
    
    for i, addr in enumerate(addresses):
        try:
            validation = gmaps.addressvalidation(
                addressLines=addr.get('lines', []),
                regionCode=addr.get('region'),
                locality=addr.get('locality'),
                enableUspsCass=addr.get('enable_usps', False)
            )
            
            result = validation['result']
            
            # Extract key information
            address_info = {
                'original': addr,
                'formatted': None,
                'valid': False,
                'complete': False,
                'geocoded': False,
                'components': []
            }
            
            # Get formatted address
            if 'address' in result and 'formattedAddress' in result['address']:
                address_info['formatted'] = result['address']['formattedAddress']
            
            # Check validation status
            if 'verdict' in result:
                verdict = result['verdict']
                address_info['complete'] = verdict.get('addressComplete', False)
                address_info['valid'] = verdict.get('validationGranularity') not in ['GRANULARITY_UNSPECIFIED', 'OTHER']
                address_info['geocoded'] = verdict.get('geocodeGranularity') not in ['GRANULARITY_UNSPECIFIED', 'OTHER']
            
            results.append(address_info)
            
        except Exception as e:
            results.append({
                'original': addr,
                'error': str(e),
                'valid': False
            })
    
    return results

# Example batch validation
address_batch = [
    {'lines': ["1600 Pennsylvania Ave", "Washington DC"], 'region': 'US', 'enable_usps': True},
    {'lines': ["350 5th Ave", "New York NY"], 'region': 'US', 'enable_usps': True},
    {'lines': ["Invalid Address XYZ", "Nowhere"], 'region': 'US'},
    {'lines': ["221B Baker Street", "London"], 'region': 'GB'}
]

validation_results = validate_address_list(address_batch)

print("Batch Validation Results:")
print("=" * 40)

for i, result in enumerate(validation_results):
    print(f"\nAddress {i+1}:")
    print(f"Original: {result['original']['lines']}")
    
    if 'error' in result:
        print(f"Error: {result['error']}")
    else:
        print(f"Formatted: {result.get('formatted', 'N/A')}")
        print(f"Valid: {result['valid']}")
        print(f"Complete: {result['complete']}")
        print(f"Geocoded: {result['geocoded']}")

import googlemaps

gmaps = googlemaps.Client(key='YOUR_API_KEY')

def standardize_address(address_lines, region_code="US"):
    """Standardize an address and show corrections."""
    
    validation = gmaps.addressvalidation(
        addressLines=address_lines,
        regionCode=region_code,
        enableUspsCass=True
    )
    
    result = validation['result']
    
    print(f"Original Address: {' '.join(address_lines)}")
    
    # Show standardized version
    if 'address' in result:
        address_info = result['address']
        
        if 'formattedAddress' in address_info:
            formatted = address_info['formattedAddress']
            print(f"Standardized: {formatted}")
        
        # Show component-level corrections
        if 'addressComponents' in address_info:
            print("\nComponent Analysis:")
            for component in address_info['addressComponents']:
                name = component['componentName']['text']
                comp_type = component['componentType']
                confirmation = component.get('confirmationLevel', 'UNKNOWN')
                
                status = ""
                if confirmation == 'CONFIRMED':
                    status = "✓"
                elif confirmation == 'UNCONFIRMED_BUT_PLAUSIBLE':
                    status = "?"
                elif confirmation == 'UNCONFIRMED_AND_SUSPICIOUS':
                    status = "⚠"
                
                print(f"  {comp_type}: {name} [{confirmation}] {status}")
    
    # Show verdict details
    if 'verdict' in result:
        verdict = result['verdict']
        print(f"\nValidation Summary:")
        print(f"  Address Complete: {verdict.get('addressComplete', False)}")
        print(f"  Has Replacements: {verdict.get('hasReplacedComponents', False)}")
        print(f"  Has Inferences: {verdict.get('hasInferredComponents', False)}")
        print(f"  Validation Level: {verdict.get('validationGranularity', 'UNKNOWN')}")

# Examples of address standardization
test_addresses = [
    ["1600 pennsylvania avenue", "washington dc 20500"],  # Case and formatting
    ["350 fifth ave", "new york ny 10118"],               # Abbreviated street
    ["1 hacker way", "menlo park ca"],                    # Modern address
    ["123 main street apt 4b", "anytown ny 12345"]       # Apartment number
]

for addr in test_addresses:
    print("=" * 60)
    standardize_address(addr)
    print()

import googlemaps

gmaps = googlemaps.Client(key='YOUR_API_KEY')

def validate_and_geocode(address_lines, region_code="US"):
    """Validate address and extract geocoding information."""
    
    validation = gmaps.addressvalidation(
        addressLines=address_lines,
        regionCode=region_code
    )
    
    result = validation['result']
    
    address_data = {
        'original': ' '.join(address_lines),
        'formatted': None,
        'coordinates': None,
        'geocode_quality': None,
        'valid': False
    }
    
    # Extract formatted address
    if 'address' in result and 'formattedAddress' in result['address']:
        address_data['formatted'] = result['address']['formattedAddress']
    
    # Extract geocoding information
    if 'geocode' in result:
        geocode_info = result['geocode']
        
        if 'location' in geocode_info:
            location = geocode_info['location']
            address_data['coordinates'] = (
                location.get('latitude'),
                location.get('longitude')
            )
        
        # Geocoding accuracy
        if 'bounds' in geocode_info:
            bounds = geocode_info['bounds']
            print(f"Geocoding bounds available: {bounds}")
    
    # Validation quality
    if 'verdict' in result:
        verdict = result['verdict']
        address_data['geocode_quality'] = verdict.get('geocodeGranularity')
        address_data['valid'] = verdict.get('addressComplete', False)
    
    return address_data

# Example usage
test_address = ["1600 Amphitheatre Parkway", "Mountain View CA 94043"]
result = validate_and_geocode(test_address)

print("Address Validation + Geocoding:")
print(f"Original: {result['original']}")
print(f"Formatted: {result['formatted']}")
print(f"Coordinates: {result['coordinates']}")
print(f"Geocode Quality: {result['geocode_quality']}")
print(f"Valid: {result['valid']}")

# Compare with regular geocoding
if result['formatted']:
    geocode_result = gmaps.geocode(result['formatted'])
    if geocode_result:
        geo_location = geocode_result[0]['geometry']['location']
        print(f"Regular Geocoding: ({geo_location['lat']}, {geo_location['lng']})")