Automate Partnership Pipeline 🚀

import time
import redis
import json

class EnrichmentCache:
    def __init__(self):
        self.redis = redis.Redis(host='localhost', port=6379, db=0)
        self.ttl = 86400 * 7  # Cache for 7 days
    
    def get_enriched_data(self, company_name: str) -> dict:
        # Check cache first
        cached = self.redis.get(f'company:{company_name}')
        if cached:
            return json.loads(cached)
        
        # Rate limit: 1 req/sec
        time.sleep(1)
        
        # Fetch from Clearbit
        response = requests.get(
            'https://company.clearbit.com/v2/companies/find',
            params={'name': company_name},
            headers={'Authorization': f'Bearer {os.getenv("CLEARBIT_KEY")}'},
            timeout=10
        )
        
        if response.status_code == 200:
            data = response.json()
            # Cache the result
            self.redis.setex(
                f'company:{company_name}',
                self.ttl,
                json.dumps(data)
            )
            return data
        
        return {}

# Usage: Batch process with caching
cache = EnrichmentCache()
for company in discovered_partners:
    enriched = cache.get_enriched_data(company['name'])
    company['enriched'] = enriched

async function upsertDeal(
  companyName: string,
  dealData: any
): Promise<string> {
  const hubspotKey = process.env.HUBSPOT_API_KEY!;

  // Search for existing deal by company name
  const searchResponse = await fetch(
    'https://api.hubapi.com/crm/v3/objects/deals/search',
    {
      method: 'POST',
      headers: {
        Authorization: `Bearer ${hubspotKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        filterGroups: [
          {
            filters: [
              {
                propertyName: 'dealname',
                operator: 'CONTAINS_TOKEN',
                value: companyName,
              },
            ],
          },
        ],
      }),
    }
  );

  const searchData = await searchResponse.json();

  if (searchData.results && searchData.results.length > 0) {
    // Update existing deal
    const dealId = searchData.results[0].id;
    await fetch(`https://api.hubapi.com/crm/v3/objects/deals/${dealId}`, {
      method: 'PATCH',
      headers: {
        Authorization: `Bearer ${hubspotKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ properties: dealData }),
    });
    return dealId;
  } else {
    // Create new deal
    const createResponse = await fetch(
      'https://api.hubapi.com/crm/v3/objects/deals',
      {
        method: 'POST',
        headers: {
          Authorization: `Bearer ${hubspotKey}`,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ properties: dealData }),
      }
    );
    const createData = await createResponse.json();
    return createData.id;
  }
}

import anthropic
import requests

def get_personalization_hooks(company_name: str, domain: str) -> dict:
    """Find recent news and signals for personalization"""
    
    # Get recent company news (using NewsAPI or similar)
    news_response = requests.get(
        'https://newsapi.org/v2/everything',
        params={
            'q': company_name,
            'sortBy': 'publishedAt',
            'pageSize': 3,
            'apiKey': os.getenv('NEWS_API_KEY')
        },
        timeout=10
    )
    
    recent_news = []
    if news_response.status_code == 200:
        articles = news_response.json().get('articles', [])
        recent_news = [a['title'] for a in articles[:3]]
    
    # Check for job postings (signals growth)
    jobs_response = requests.get(
        f'https://api.lever.co/v0/postings/{domain}',
        timeout=10
    )
    
    open_roles = []
    if jobs_response.status_code == 200:
        jobs = jobs_response.json()
        open_roles = [j['text'] for j in jobs[:5]]
    
    return {
        'recent_news': recent_news,
        'open_roles': open_roles,
        'hiring_signals': len(open_roles) > 0
    }

def generate_personalized_outreach(partner: dict) -> str:
    """Generate outreach with personalization hooks"""
    hooks = get_personalization_hooks(
        partner['company'],
        partner['enriched'].get('domain', '')
    )
    
    client = anthropic.Anthropic(api_key=os.getenv('ANTHROPIC_API_KEY'))
    
    prompt = f"""Create a personalized LinkedIn message for this partnership opportunity.

Target: {partner['company']}
Why good fit: {partner['why_good_fit']}
Recent news: {hooks['recent_news']}
Open roles: {hooks['open_roles']}

Make it:
1. Reference specific recent news or hiring
2. Show you understand their business
3. Clear value prop in 2 sentences
4. Soft ask for 15 min call

Keep under 150 words."""
    
    response = client.messages.create(
        model='claude-3-5-sonnet-20241022',
        max_tokens=512,
        messages=[{'role': 'user', 'content': prompt}]
    )
    
    content = response.content[0]
    if content.type != 'text':
        raise ValueError('Invalid response')
    
    return content.text

interface EngagementSignal {
  type: 'email_open' | 'link_click' | 'meeting_booked' | 'response';
  timestamp: Date;
  metadata?: any;
}

function calculateDealHealth(
  baseScore: number,
  signals: EngagementSignal[]
): number {
  let score = baseScore;

  // Recent signals matter more (decay over time)
  const now = new Date();
  const daysSinceLastSignal = signals.length
    ? (now.getTime() - signals[signals.length - 1].timestamp.getTime()) /
      (1000 * 60 * 60 * 24)
    : 999;

  // Penalize stale deals
  if (daysSinceLastSignal > 14) {
    score -= 20;
  } else if (daysSinceLastSignal > 7) {
    score -= 10;
  }

  // Positive signals in last 7 days
  const recentSignals = signals.filter(
    (s) =>
      (now.getTime() - s.timestamp.getTime()) / (1000 * 60 * 60 * 24) <= 7
  );

  recentSignals.forEach((signal) => {
    switch (signal.type) {
      case 'email_open':
        score += 5;
        break;
      case 'link_click':
        score += 10;
        break;
      case 'meeting_booked':
        score += 25;
        break;
      case 'response':
        score += 15;
        break;
    }
  });

  // Cap between 0-100
  return Math.max(0, Math.min(100, score));
}

// Usage: Update health score based on real engagement
const signals: EngagementSignal[] = [
  { type: 'email_open', timestamp: new Date('2025-09-01') },
  { type: 'link_click', timestamp: new Date('2025-09-02') },
  { type: 'meeting_booked', timestamp: new Date('2025-09-03') },
];

const healthScore = calculateDealHealth(75, signals);
console.log(`Updated health score: ${healthScore}`);

import requests
import base64
import os

def send_partnership_contract(
    partner_name: str,
    partner_email: str,
    deal_terms: dict
) -> str:
    """Send partnership agreement via DocuSign"""
    
    docusign_account_id = os.getenv('DOCUSIGN_ACCOUNT_ID')
    docusign_access_token = os.getenv('DOCUSIGN_ACCESS_TOKEN')
    template_id = os.getenv('DOCUSIGN_PARTNERSHIP_TEMPLATE_ID')
    
    # Create envelope from template
    envelope_definition = {
        'templateId': template_id,
        'templateRoles': [
            {
                'email': partner_email,
                'name': partner_name,
                'roleName': 'Partner',
                'tabs': {
                    'textTabs': [
                        {
                            'tabLabel': 'PartnerName',
                            'value': partner_name
                        },
                        {
                            'tabLabel': 'DealValue',
                            'value': deal_terms.get('value', '')
                        },
                        {
                            'tabLabel': 'StartDate',
                            'value': deal_terms.get('start_date', '')
                        }
                    ]
                }
            }
        ],
        'status': 'sent'
    }
    
    response = requests.post(
        f'https://demo.docusign.net/restapi/v2.1/accounts/{docusign_account_id}/envelopes',
        headers={
            'Authorization': f'Bearer {docusign_access_token}',
            'Content-Type': 'application/json'
        },
        json=envelope_definition,
        timeout=10
    )
    
    if response.status_code == 201:
        envelope_id = response.json()['envelopeId']
        print(f'Contract sent! Envelope ID: {envelope_id}')
        return envelope_id
    else:
        raise Exception(f'DocuSign API error: {response.text}')

# Usage: Auto-send contract when deal reaches "Closing" stage
deal_terms = {
    'value': '$250,000 ARR',
    'start_date': '2025-10-01',
    'duration': '12 months'
}

envelope_id = send_partnership_contract(
    'Lattice',
    'partnerships@lattice.com',
    deal_terms
)