Calls WHOIS Email end point

        Args:
            emails: An enumerable of string Emails
        Returns:
            A dict of {email: domain_result}
556783
def whois_emails(self, emails):
        
        api_name = 'opendns-whois-emails'
        fmt_url_path = u'whois/emails/{0}'
        return self._multi_get(api_name, fmt_url_path, emails)
182168
def delete_user_by_email(self, email):
	
		
		call = "/api/users/"+ str(email)

		return self.api_call(call=call, method="DELETE")
978844
def verifyEmails(emails=[], regExpPattern="^.+$"):
    
    emailsMatched = set()

    for i, e in enumerate(emails):
        if re.match(regExpPattern, e):
            emailsMatched.add(e)

    print(regExpPattern)

    return list(emailsMatched)
1216923
def __parse(self, aliases, email_to_employer, domain_to_employer):
        """"""

        self.__parse_organizations(domain_to_employer)
        self.__parse_identities(aliases, email_to_employer)
43613
def get_email_context(self,**kwargs):
        '''  '''
        context = super(Customer,self).get_email_context(**kwargs)
        context.update({
            'first_name': self.first_name,
            'last_name': self.last_name,
            'email': self.email,
            'fullName': self.fullName,
            'phone': self.phone,
        })
        return context
316157
def lists_for_email(self, email_address):
        """"""
        params = {"email": email_address}
        response = self._get(self.uri_for("listsforemail"), params=params)
        return json_to_py(response)
984743
def whois_domains(self, domains):
        
        api_name = 'opendns-whois-domain'
        fmt_url_path = u'whois/{0}'
        return self._multi_get(api_name, fmt_url_path, domains)
773880
def get_domain(self, identity):
        
        domain = None
        if identity['email']:
            try:
                domain = identity['email'].split("@")[1]
            except IndexError:
                # logger.warning("Bad email format: %s" % (identity['email']))
                pass
        return domain
1086145
def add_email_addresses(self, addresses=[]):
        
        json = []
        if addresses:
            url = self._build_url('user', 'emails')
            json = self._json(self._post(url, data=addresses), 201)
        return json
452076
def _extract_email(data):
    
    ret = ''
    elements = data.get('elements', [])
    if len(elements) > 0:
        ret = elements[0].get('handle~', {}).get('emailAddress', '')
    return ret
475902
def domain_whois(self, domain):
        ''''''
        uri = self._uris["whois_domain"].format(domain)
        resp_json = self.get_parse(uri)
        return resp_json
545484
def email_list_to_email_dict(email_list):
    """"""
    if email_list is None:
        return {}
    result = {}
    for value in email_list:
        realname, address = email.utils.parseaddr(value)
        result[address] = realname if realname and address else address
    return result
507168
def count_emails(self, conditions={}):
        
        url = self.EMAILS_COUNT_URL + "?"

        for key, value in conditions.items():
            if key is 'ids':
                value = ",".join(value)

            url += '&%s=%s' % (key, value)

        connection = Connection(self.token)
        connection.set_url(self.production, url)
        connection.set_url(self.production, url)

        return connection.get_request()
370607
def get_owner_emails(self, partial_owner_match=True):
        
        for tag in self.tags:
            if tag.key.lower() == 'owner':
                rgx = re.compile(RGX_EMAIL_VALIDATION_PATTERN, re.I)
                if partial_owner_match:
                    match = rgx.findall(tag.value)
                    if match:
                        return [NotificationContact('email', email) for email in match]
                else:
                    match = rgx.match(tag.value)
                    if match:
                        return [NotificationContact('email', email) for email in match.groups()]
        return None
447519
def extract_emails(results: str, domain: str, fuzzy: bool) -> List[str]:
    """"""
    pattern: Pattern = re.compile(r'([\w.-]+@[\w.-]+)')
    hits: List[str] = pattern.findall(results)
    if fuzzy:
        seed = domain.split('.')[0]
        emails: List[str] = [x.lower() for x in hits if x.split('@')[1].__contains__(seed)]
    else:
        emails: List[str] = [x.lower() for x in hits if x.endswith(domain)]
    return list(set(emails))
1181476
public SpamAnalysisResult spam(String email) throws IOException, MailosaurException {
    	return client.request("GET", "api/analysis/spam/" + email).parseAs(SpamAnalysisResult.class);
    }
255556
private Map<String, String> getEmails(Map<String, String> emails) {

		if (emails == null || emails.size() == 0) {
			return null;
		}

		Map<String, String> out = new HashMap<>();

		for (String email : emails.keySet()) {
			if (excluded(email)) {
				continue;
			}

			out.put(email, emails.get(email));
		}

		return out;
	}