Create a new bulk verification job for the list of emails.
        :param list emails: Email addresses to verify.
        :return: A Job object.
488237
def create_job(self, emails):
        
        resp = self._call(endpoint='bulk', data={'input_location': '1', 'input': '\n'.join(emails)})
        return Job(resp['job_id'])
935697
def list(self, id=None):
        
        args = {'id': id}
        self._job_chk.check(args)
        return self._client.json('job.list', args)
153258
def list_file_jobs(cls, offset=None, limit=None, api=None):
        
        api = api or cls._API
        return super(AsyncJob, cls)._query(
            api=api,
            url=cls._URL['list_file_jobs'],
            offset=offset,
            limit=limit,
        )
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))
1071816
def verify_account(self, email_address):
        ''' 
        '''
        request = self._get_request()
        resp = request.post(self.ACCOUNT_VERIFY_URL, {
            'email_address': email_address
        })
        return ('account' in resp)
100757
def create_emailconfirmation(self, email_address):
        ""
        confirmation_key = self.generate_key(email_address.email)
        confirmation = self.create(
            email_address=email_address,
            created_at=now(),
            key=confirmation_key,
        )
        return confirmation
789894
def list(self, allJobs=False):
        

        jobs = self.server.call('get', '/job')

        return [Job(job['id'], self.server) for job in jobs if allJobs or self._job_owned(job)]
1246362
def create_email_verification(self, body):
        
        return self.client.post(self._url('email-verification'), data=body)
854301
def create_mailing_lists(self, verbose=True):
        
        responses = {}
        if (
            settings.EMAIL_ENABLED
            and self.loaded
            and settings.EMAIL_BACKEND
            != "django.core.mail.backends.locmem.EmailBackend"
        ):
            sys.stdout.write(style.MIGRATE_HEADING(f"Creating mailing lists:\n"))
            for name, notification_cls in self.registry.items():
                message = None
                notification = notification_cls()
                manager = MailingListManager(
                    address=notification.email_to,
                    name=notification.name,
                    display_name=notification.display_name,
                )
                try:
                    response = manager.create()
                except ConnectionError as e:
                    sys.stdout.write(
                        style.ERROR(
                            f"  * Failed to create mailing list {name}. " f"Got {e}\n"
                        )
                    )
                else:
                    if verbose:
                        try:
                            message = response.json().get("message")
                        except JSONDecodeError:
                            message = response.text
                        sys.stdout.write(
                            f"  * Creating mailing list {name}. "
                            f'Got {response.status_code}: "{message}"\n'
                        )
                    responses.update({name: response})
        return responses
1089105
def load_contacts email_addresses, opts={}
    contacts = Set.new
    num = opts[:num] || 20
    each_id_by_date :participants => email_addresses do |id,b|
      break if contacts.size >= num
      m = b.call
      ([m.from]+m.to+m.cc+m.bcc).compact.each { |p| contacts << [p.name, p.email] }
    end
    contacts.to_a.compact[0...num].map { |n,e| Person.from_name_and_email n, e }
  end
346498
def create_job_template(self, template):
        
        endpoint = self._build_url('jobTemplates')
        data = self._query_api('POST',
                               endpoint,
                               None,
                               {'Content-Type': 'application/json'},
                               json.dumps(template))
        return data['results']
559256
def verify(self, email):
        
        resp = self._call(endpoint='single', data={'email': email})
        return VerifiedEmail(email, resp['result'])
69275
def save_email(self, list_name, email_msg, index):
        """"""

        msg_id = email_msg.get('Message-ID')
        if not msg_id:
            return

        # Update last imported message into the DB
        mailinglist, created = MailingList.objects.get_or_create(
            name=list_name
        )
        mailinglist.last_imported_index = index

        if created:
            # if the mailinglist is newly created it's sure that the message
            #   is not in the DB yet.
            self.create_email(mailinglist, email_msg)

        else:
            # If the message is already at the database don't do anything
            try:
                Message.all_objects.get(
                    message_id=msg_id,
                    thread__mailinglist=mailinglist
                )

            except Message.DoesNotExist:
                self.create_email(mailinglist, email_msg)

        mailinglist.save()
769168
def create_list_item(self, new_data):
        

        url = self.build_url(self._endpoints.get('get_items'))

        response = self.con.post(url, {'fields': new_data})
        if not response:
            return False

        data = response.json()

        return self.list_item_constructor(parent=self, **{self._cloud_data_key: data})
837875
def add_email_address(self, email, hidden=None):
        
        existing_emails = get_value(self.obj, 'email_addresses', [])
        found_email = next(
            (existing_email for existing_email in existing_emails if existing_email.get('value') == email),
            None
        )
        if found_email is None:
            new_email = {'value': email}
            if hidden is not None:
                new_email['hidden'] = hidden
            self._append_to('email_addresses', new_email)
        elif hidden is not None:
            found_email['hidden'] = hidden
394874
def delete_email_addresses(self, addresses=[]):
        
        url = self._build_url('user', 'emails')
        return self._boolean(self._delete(url, data=dumps(addresses)),
                             204, 404)
1297855
def update_after_verification(self, user):
        
        if not self.is_fully_verified():
            return

        classification = 'autoclassified intermittent'

        already_classified = (JobNote.objects.filter(job=self)
                                             .exclude(failure_classification__name=classification)
                                             .exists())
        if already_classified:
            # Don't add an autoclassification note if a Human already
            # classified this job.
            return

        JobNote.create_autoclassify_job_note(job=self, user=user)