Best SmartReach.io Phone Validation API & Email Verification Integration 2025

import requests
import json
import asyncio
from typing import Dict, List, Optional
from dataclasses import dataclass, asdict
from datetime import datetime

@dataclass
class CRMIntegratedContact:
    email: str
    first_name: Optional[str] = None
    last_name: Optional[str] = None
    position: Optional[str] = None
    company: Optional[str] = None
    domain: Optional[str] = None
    phone: Optional[str] = None
    linkedin_url: Optional[str] = None
    crm_id: Optional[str] = None
    email_validation: Optional[Dict] = None
    phone_validation: Optional[Dict] = None
    crm_intelligence: Optional[Dict] = None
    automation_data: Optional[Dict] = None
    deliverability_score: int = 0
    crm_score: int = 0
    automation_priority: str = "medium"
    crm_sync_quality: str = "basic"
    smartreach_readiness: str = "pending"
    crm_optimization: Optional[Dict] = None
    enhancement_timestamp: str = ""

class SmartReach1lookupIntegration:
    def __init__(self, smartreach_api_key: str, lookup_api_key: str, crm_type: str = "salesforce"):
        self.smartreach_api_key = smartreach_api_key
        self.lookup_api_key = lookup_api_key
        self.crm_type = crm_type
        self.smartreach_base_url = "https://api.smartreach.io/v1"
        self.lookup_base_url = "https://api.1lookup.app/v1"
    
    async def optimize_crm_integrated_campaign(self, campaign_id: str, 
                                             crm_mapping: Dict = None) -> Dict:
        """
        Optimize SmartReach campaign with comprehensive CRM-integrated intelligence
        """
        try:
            # Step 1: Get campaign contacts from SmartReach
            campaign_contacts = await self._get_smartreach_campaign_contacts(campaign_id)
            
            if not campaign_contacts:
                return {"error": "No contacts found in campaign"}
            
            # Step 2: Enhance all contacts with CRM intelligence
            enhanced_contacts = await self._bulk_enhance_for_crm_integration(campaign_contacts)
            
            # Step 3: Generate CRM optimization strategies
            crm_optimization = await self._generate_crm_optimization_strategies(enhanced_contacts)
            
            # Step 4: Create multi-channel enhancement recommendations
            multichannel_enhancement = self._generate_multichannel_enhancements(enhanced_contacts)
            
            # Step 5: Update SmartReach campaign and CRM with enhanced data
            update_results = await self._update_smartreach_and_crm(campaign_id, enhanced_contacts, crm_mapping)
            
            return {
                "campaign_id": campaign_id,
                "total_contacts": len(campaign_contacts),
                "enhanced_contacts": len(enhanced_contacts),
                "crm_integration_stats": self._calculate_crm_integration_stats(enhanced_contacts),
                "crm_optimization": crm_optimization,
                "multichannel_enhancement": multichannel_enhancement,
                "update_results": update_results
            }
            
        except Exception as e:
            return {"error": f"CRM-integrated campaign optimization failed: {e}"}
    
    async def create_enhanced_crm_campaign(self, campaign_name: str,
                                         contacts: List[Dict],
                                         crm_config: Dict = None) -> Dict:
        """
        Create enhanced SmartReach campaign with comprehensive CRM optimization
        """
        try:
            # Step 1: Enhance contacts with CRM intelligence
            enhanced_contacts = await self._bulk_enhance_for_crm_integration(contacts)
            
            # Step 2: Generate optimized CRM-integrated campaign structure
            campaign_structure = await self._generate_crm_campaign_structure(
                enhanced_contacts, crm_config
            )
            
            # Step 3: Create SmartReach campaign with CRM optimization
            campaign_data = await self._create_smartreach_campaign(campaign_name, campaign_structure)
            
            if not campaign_data:
                return {"error": "Failed to create SmartReach campaign"}
            
            # Step 4: Apply CRM integration optimizations
            optimization_results = await self._apply_crm_integration_optimizations(
                campaign_data['id'], enhanced_contacts
            )
            
            return {
                "campaign_id": campaign_data['id'],
                "campaign_name": campaign_name,
                "total_contacts": len(enhanced_contacts),
                "crm_integration_optimization": self._analyze_crm_integration_optimization(enhanced_contacts),
                "optimization_results": optimization_results
            }
            
        except Exception as e:
            return {"error": f"Enhanced CRM campaign creation failed: {e}"}
    
    async def _bulk_enhance_for_crm_integration(self, contacts: List[Dict]) -> List[CRMIntegratedContact]:
        """Enhance multiple contacts for optimal CRM-integrated campaigns"""
        enhancement_tasks = []
        
        for contact_data in contacts:
            crm_contact = CRMIntegratedContact(
                email=contact_data.get('email', ''),
                first_name=contact_data.get('first_name') or contact_data.get('firstName'),
                last_name=contact_data.get('last_name') or contact_data.get('lastName'),
                position=contact_data.get('position') or contact_data.get('title'),
                company=contact_data.get('company'),
                domain=contact_data.get('domain'),
                linkedin_url=contact_data.get('linkedin_url'),
                crm_id=contact_data.get('crm_id') or contact_data.get('contact_id'),
                enhancement_timestamp=datetime.now().isoformat()
            )
            
            task = self._enhance_single_contact_for_crm_integration(crm_contact)
            enhancement_tasks.append(task)
        
        # Process all enhancements in parallel
        await asyncio.gather(*enhancement_tasks, return_exceptions=True)
        
        return [task.result() for task in enhancement_tasks if not isinstance(task.result(), Exception)]
    
    async def _enhance_single_contact_for_crm_integration(self, contact: CRMIntegratedContact) -> None:
        """Comprehensive single contact enhancement for CRM-integrated campaigns"""
        enhancement_tasks = []
        
        # Email validation with CRM optimization
        if contact.email:
            task1 = self._validate_email_for_crm_integration(contact.email)
            enhancement_tasks.append(task1)
        
        # Phone enrichment for CRM completion
        if contact.first_name and contact.last_name:
            task2 = self._enrich_phone_for_crm_integration(contact)
            enhancement_tasks.append(task2)
        
        # CRM intelligence gathering
        task3 = self._gather_crm_integration_intelligence(contact)
        enhancement_tasks.append(task3)
        
        # Execute all enhancements
        results = await asyncio.gather(*enhancement_tasks, return_exceptions=True)
        
        # Process email validation
        if len(results) > 0 and not isinstance(results[0], Exception):
            contact.email_validation = results[0]
            contact.deliverability_score = results[0].get('deliverability_score', 0)
        
        # Process phone enrichment
        if len(results) > 1 and not isinstance(results[1], Exception) and results[1]:
            contact.phone_validation = results[1]
            contact.phone = results[1].get('phone_number')
        
        # Process CRM intelligence
        if len(results) > 2 and not isinstance(results[2], Exception):
            contact.crm_intelligence = results[2]
        
        # Generate automation data for SmartReach
        contact.automation_data = self._generate_automation_data(contact)
        
        # Calculate CRM integration scores and optimizations
        contact.crm_score = self._calculate_crm_integration_score(contact)
        contact.automation_priority = self._determine_automation_priority(contact)
        contact.crm_sync_quality = self._assess_crm_sync_quality(contact)
        contact.smartreach_readiness = self._assess_smartreach_readiness(contact)
        contact.crm_optimization = self._generate_crm_optimization_recommendations(contact)
    
    async def _validate_email_for_crm_integration(self, email: str) -> Dict:
        """Advanced email validation optimized for CRM integration"""
        url = f"{self.lookup_base_url}/email/validate"
        headers = {
            'Authorization': f'Bearer {self.lookup_api_key}',
            'Content-Type': 'application/json'
        }
        
        payload = {
            'email': email,
            'crm_integration_focus': True,
            'automation_optimization': True,
            'deliverability_intelligence': True,
            'data_quality_assessment': True
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(url, json=payload, headers=headers) as response:
                if response.status == 200:
                    result = await response.json()
                    
                    # Calculate CRM integration deliverability score
                    score = 0
                    if result.get('deliverable'): score += 35
                    if result.get('valid_format'): score += 20
                    if not result.get('spam_trap'): score += 20
                    if result.get('crm_friendly', True): score += 25
                    
                    result['deliverability_score'] = score
                    result['crm_integration_quality'] = 'excellent' if score >= 85 else 'good' if score >= 70 else 'fair' if score >= 50 else 'poor'
                    return result
                return {'deliverable': False, 'deliverability_score': 0, 'crm_integration_quality': 'poor'}
    
    async def _enrich_phone_for_crm_integration(self, contact: CRMIntegratedContact) -> Optional[Dict]:
        """Phone enrichment optimized for CRM integration and automation"""
        url = f"{self.lookup_base_url}/enrich/phone"
        headers = {
            'Authorization': f'Bearer {self.lookup_api_key}',
            'Content-Type': 'application/json'
        }
        
        payload = {
            'first_name': contact.first_name,
            'last_name': contact.last_name,
            'company': contact.company,
            'domain': contact.domain,
            'email': contact.email,
            'crm_integration_focus': True,
            'automation_enhancement': True
        }
        
        try:
            async with aiohttp.ClientSession() as session:
                async with session.post(url, json=payload, headers=headers) as response:
                    if response.status == 200:
                        result = await response.json()
                        
                        # Assess CRM integration value
                        if result.get('valid'):
                            result['crm_integration_score'] = 95 if result.get('business_phone') else 80 if result.get('mobile') else 65
                            result['automation_enhancement_value'] = 'high'
                        else:
                            result['crm_integration_score'] = 0
                            result['automation_enhancement_value'] = 'low'
                        
                        return result
        except:
            pass
        
        return None
    
    async def _gather_crm_integration_intelligence(self, contact: CRMIntegratedContact) -> Optional[Dict]:
        """Gather comprehensive intelligence for CRM integration optimization"""
        url = f"{self.lookup_base_url}/enrich/crm_intelligence"
        headers = {
            'Authorization': f'Bearer {self.lookup_api_key}',
            'Content-Type': 'application/json'
        }
        
        payload = {
            'first_name': contact.first_name,
            'last_name': contact.last_name,
            'company': contact.company,
            'email': contact.email,
            'position': contact.position,
            'crm_type': self.crm_type,
            'automation_intelligence': True,
            'data_quality_focus': True
        }
        
        try:
            async with aiohttp.ClientSession() as session:
                async with session.post(url, json=payload, headers=headers) as response:
                    if response.status == 200:
                        return await response.json()
        except:
            pass
        
        return None
    
    def _generate_automation_data(self, contact: CRMIntegratedContact) -> Dict:
        """Generate comprehensive automation data for SmartReach"""
        automation_data = {
            'sequence_variables': {},
            'crm_fields': {},
            'multichannel_data': {},
            'personalization_hooks': [],
            'automation_triggers': {}
        }
        
        # Sequence variables for SmartReach automation
        automation_data['sequence_variables'] = {
            'first_name': contact.first_name or 'there',
            'company': contact.company or 'your company',
            'position': contact.position or 'your role',
            'validated_email': contact.email if contact.email_validation and contact.email_validation.get('deliverable') else 'email_needs_verification',
            'validated_phone': contact.phone if contact.phone_validation and contact.phone_validation.get('valid') else 'phone_not_available'
        }
        
        # CRM field mappings
        automation_data['crm_fields'] = {
            'email_status': 'verified' if contact.email_validation and contact.email_validation.get('deliverable') else 'unverified',
            'phone_status': 'verified' if contact.phone_validation and contact.phone_validation.get('valid') else 'unverified',
            'data_quality_score': contact.crm_score,
            'automation_readiness': contact.smartreach_readiness,
            'last_enhanced': contact.enhancement_timestamp
        }
        
        # Multi-channel data for enhanced sequences
        channels = ['email']
        if contact.phone_validation and contact.phone_validation.get('valid'):
            channels.append('phone')
        if contact.linkedin_url:
            channels.append('linkedin')
        
        automation_data['multichannel_data'] = {
            'available_channels': channels,
            'recommended_sequence': self._recommend_sequence_type(channels, contact.crm_score),
            'channel_priority': self._determine_channel_priority(channels, contact)
        }
        
        # Personalization hooks for automation
        hooks = []
        if contact.crm_intelligence:
            if contact.crm_intelligence.get('company_insights'):
                hooks.append("I noticed your company's recent growth...")
            if contact.crm_intelligence.get('role_insights'):
                hooks.append(f"In your role as {contact.position}, you likely...")
        
        automation_data['personalization_hooks'] = hooks[:2]
        
        # Automation triggers based on CRM data
        automation_data['automation_triggers'] = {
            'high_value_prospect': contact.crm_score >= 80,
            'phone_followup_eligible': bool(contact.phone_validation and contact.phone_validation.get('valid')),
            'linkedin_outreach_ready': bool(contact.linkedin_url),
            'crm_sync_priority': contact.crm_sync_quality in ['excellent', 'good']
        }
        
        return automation_data
    
    def _calculate_crm_integration_score(self, contact: CRMIntegratedContact) -> int:
        """Calculate comprehensive CRM integration score"""
        score = 0
        
        # Email deliverability for CRM sync (0-35 points)
        score += contact.deliverability_score * 0.35
        
        # Contact completeness for CRM data quality (0-30 points)
        completeness = 0
        if contact.email: completeness += 10
        if contact.first_name and contact.last_name: completeness += 8
        if contact.company: completeness += 6
        if contact.position: completeness += 4
        if contact.phone: completeness += 2
        score += completeness
        
        # CRM intelligence quality (0-20 points)
        if contact.crm_intelligence:
            intelligence_quality = len([v for v in contact.crm_intelligence.values() if v])
            score += min(intelligence_quality * 2, 20)
        
        # Multi-channel capability for automation (0-15 points)
        channels = 1  # Email
        if contact.phone_validation and contact.phone_validation.get('valid'): channels += 1
        if contact.linkedin_url: channels += 1
        score += min(channels * 5, 15)
        
        return min(int(score), 100)
    
    def _determine_automation_priority(self, contact: CRMIntegratedContact) -> str:
        """Determine automation priority based on CRM integration score"""
        if contact.crm_score >= 85:
            return "critical"
        elif contact.crm_score >= 70:
            return "high"
        elif contact.crm_score >= 50:
            return "medium"
        else:
            return "low"
    
    def _assess_crm_sync_quality(self, contact: CRMIntegratedContact) -> str:
        """Assess CRM synchronization data quality"""
        quality_factors = 0
        
        # Essential CRM fields
        if contact.email and contact.email_validation and contact.email_validation.get('deliverable'):
            quality_factors += 2
        if contact.first_name and contact.last_name:
            quality_factors += 2
        if contact.company and contact.position:
            quality_factors += 2
        if contact.phone_validation and contact.phone_validation.get('valid'):
            quality_factors += 2
        if contact.crm_intelligence:
            quality_factors += 1
        
        if quality_factors >= 8:
            return "excellent"
        elif quality_factors >= 6:
            return "good"
        elif quality_factors >= 4:
            return "fair"
        else:
            return "basic"
    
    def _assess_smartreach_readiness(self, contact: CRMIntegratedContact) -> str:
        """Assess contact's readiness for SmartReach automation"""
        readiness_score = 0
        
        # Email deliverability
        if contact.email_validation and contact.email_validation.get('deliverable'):
            readiness_score += 3
        
        # CRM integration quality
        crm_quality = contact.email_validation.get('crm_integration_quality', 'poor') if contact.email_validation else 'poor'
        if crm_quality == 'excellent':
            readiness_score += 3
        elif crm_quality == 'good':
            readiness_score += 2
        
        # Multi-channel capability
        if contact.phone_validation and contact.phone_validation.get('valid'):
            readiness_score += 2
        
        # Professional information completeness
        if contact.position and contact.company:
            readiness_score += 1
        
        # CRM intelligence availability
        if contact.crm_intelligence:
            readiness_score += 1
        
        if readiness_score >= 9:
            return "excellent"
        elif readiness_score >= 7:
            return "good"
        elif readiness_score >= 5:
            return "fair"
        else:
            return "limited"
    
    def _generate_crm_optimization_recommendations(self, contact: CRMIntegratedContact) -> Dict:
        """Generate CRM optimization recommendations for SmartReach"""
        optimization = {
            'crm_field_mappings': {},
            'automation_triggers': {},
            'sequence_configuration': {},
            'data_enrichment_priority': [],
            'sync_recommendations': {}
        }
        
        # CRM field mappings
        optimization['crm_field_mappings'] = {
            'email_verified': contact.email_validation.get('deliverable', False) if contact.email_validation else False,
            'phone_verified': contact.phone_validation.get('valid', False) if contact.phone_validation else False,
            'data_quality_score': contact.crm_score,
            'automation_priority': contact.automation_priority,
            'enhancement_date': contact.enhancement_timestamp
        }
        
        # Automation triggers based on CRM data quality
        optimization['automation_triggers'] = {
            'high_quality_prospect': contact.crm_score >= 80,
            'phone_follow_up_ready': bool(contact.phone_validation and contact.phone_validation.get('valid')),
            'linkedin_outreach_ready': bool(contact.linkedin_url),
            'immediate_sync_required': contact.crm_sync_quality in ['excellent', 'good']
        }
        
        # Sequence configuration recommendations
        if contact.crm_score >= 80:
            optimization['sequence_configuration'] = {
                'sequence_type': 'premium_crm_integrated',
                'personalization_level': 'high',
                'follow_up_frequency': 'aggressive'
            }
        elif contact.crm_score >= 60:
            optimization['sequence_configuration'] = {
                'sequence_type': 'enhanced_crm_sync',
                'personalization_level': 'medium',
                'follow_up_frequency': 'standard'
            }
        else:
            optimization['sequence_configuration'] = {
                'sequence_type': 'basic_automated',
                'personalization_level': 'basic',
                'follow_up_frequency': 'conservative'
            }
        
        # Data enrichment priorities
        priorities = []
        if not (contact.email_validation and contact.email_validation.get('deliverable')):
            priorities.append('email_validation')
        if not (contact.phone_validation and contact.phone_validation.get('valid')):
            priorities.append('phone_enrichment')
        if not contact.crm_intelligence:
            priorities.append('crm_intelligence_gathering')
        
        optimization['data_enrichment_priority'] = priorities
        
        # CRM sync recommendations
        optimization['sync_recommendations'] = {
            'immediate_sync_required': contact.crm_sync_quality in ['excellent', 'good'],
            'sync_frequency': 'real_time' if contact.crm_score >= 70 else 'hourly',
            'bidirectional_sync': contact.crm_score >= 60,
            'automation_integration': contact.smartreach_readiness in ['excellent', 'good']
        }
        
        return optimization
    
    def _calculate_crm_integration_stats(self, contacts: List[CRMIntegratedContact]) -> Dict:
        """Calculate comprehensive CRM integration statistics"""
        total = len(contacts)
        if total == 0:
            return {}
        
        deliverable = sum(1 for c in contacts if c.email_validation and c.email_validation.get('deliverable'))
        high_crm_score = sum(1 for c in contacts if c.crm_score >= 70)
        phone_enhanced = sum(1 for c in contacts if c.phone_validation and c.phone_validation.get('valid'))
        smartreach_ready = sum(1 for c in contacts if c.smartreach_readiness in ['excellent', 'good'])
        excellent_sync_quality = sum(1 for c in contacts if c.crm_sync_quality in ['excellent', 'good'])
        
        return {
            'total_contacts': total,
            'deliverable_rate': (deliverable / total) * 100,
            'high_crm_score_rate': (high_crm_score / total) * 100,
            'phone_enhanced_rate': (phone_enhanced / total) * 100,
            'smartreach_ready_rate': (smartreach_ready / total) * 100,
            'excellent_sync_quality_rate': (excellent_sync_quality / total) * 100,
            'average_crm_score': sum(c.crm_score for c in contacts) / total,
            'critical_priority_contacts': sum(1 for c in contacts if c.automation_priority == 'critical')
        }

# Example usage for SmartReach CRM integration optimization
async def main():
    integration = SmartReach1lookupIntegration(
        smartreach_api_key="your_smartreach_api_key",
        lookup_api_key="your_1lookup_api_key",
        crm_type="salesforce"
    )
    
    # Sample contacts for CRM integration enhancement
    sample_contacts = [
        {
            'email': 'john@example.com',
            'first_name': 'John',
            'last_name': 'Smith',
            'position': 'Sales Director',
            'company': 'Example Corp',
            'crm_id': 'sf_contact_12345'
        },
        # Add more contacts...
    ]
    
    # Create enhanced CRM campaign
    campaign_result = await integration.create_enhanced_crm_campaign(
        campaign_name="CRM-Integrated Outreach Q1",
        contacts=sample_contacts,
        crm_config={
            "sync_frequency": "real_time",
            "bidirectional": True,
            "automation_triggers": True
        }
    )
    
    print("SmartReach CRM Integration Enhancement Results:")
    print(f"Campaign ID: {campaign_result.get('campaign_id')}")
    print(f"Total Contacts: {campaign_result.get('total_contacts')}")
    
    crm_optimization = campaign_result.get('crm_integration_optimization', {})
    print(f"
CRM Integration Statistics:")
    print(f"High CRM Score Rate: {crm_optimization.get('high_crm_score_rate', 0):.1f}%")
    print(f"SmartReach Ready Rate: {crm_optimization.get('smartreach_ready_rate', 0):.1f}%")
    print(f"Excellent Sync Quality Rate: {crm_optimization.get('excellent_sync_quality_rate', 0):.1f}%")

# Run the integration
if __name__ == "__main__":
    import aiohttp
    asyncio.run(main())