def register():
if request.method == "POST":
email = request.form['email']
# checks if email exists in database
user = User.query.filter_by(email=email).first()
if not user:
email_db = ''
else:
email_db = user.email
if email != email_db:
try:
# validate email using hunter
hunter = PyHunter('fce98eff8d99f93fe14df75bf06d0713d73f406a')
hunter.email_verifier(email)
# gets additional information for a user using clearbit
clearbit.key = 'sk_074ad5265e753838e4bc9993b1a1473f'
person = clearbit.Person.find(email=email, stream=True)
bio = None
if person is not None and person['bio'] is not None:
bio = person['bio']
role = None
if person is not None and person['employment']['role'] is not None:
role = person['employment']['role']
location = None
if person is not None and person['location'] is not None:
location = person['location']
# inserts new user into database
new_user = User(public_id=str(uuid.uuid4()), first_name=request.form['first_name'],
last_name=request.form['last_name'], email=email, password=request.form['password'],
bio=bio, role=role, location=location)
db.session.add(new_user)
db.session.commit()
return render_template('login.html')
except:
return render_template('invalid.html')
else:
return render_template('userexists.html')
return render_template('register.html')
def create(self, validated_data):
user = User(
email=validated_data['email'],
first_name=validated_data['first_name'],
last_name=validated_data['last_name']
)
user.set_password(validated_data['password'])
user.is_active = True
hunter = PyHunter(settings.HUNTER_API_KEY)
hunter.email_verifier(user.email)
pp = pprint.PrettyPrinter(indent=4)
pp.pprint(hunter.email_verifier(user.email))
user.save()
return user
def create(self, request, *args, **kwargs):
#check email by EmailHunter
#if it's failed, send status 400
hunter = PyHunter(EMAIL_HUNTER_API_KEY)
verify = hunter.email_verifier(request.data['email'])
if verify.get('result', {}) == 'undelivarable':
return Response(status=status.HTTP_400_BAD_REQUEST)
#enrich account by first name and last name using clearbit
clearbit.key = CLEARBIT_APY_KEY
res = clearbit.Enrichment.find(email=request.data['email'])
try:
request.data['first_name'] = res['person']['name'].get(
'givenName', '')
request.data['last_name'] = res['person']['name'].get(
'familyName', '')
except (TypeError, KeyError):
#if enrichment is failed, set fields as empty strings
request.data['first_name'] = request.data['last_name'] = ''
#serialize data from request
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
#and create a user
self.perform_create(serializer)
#define headers and respond to client
headers = self.get_success_headers(serializer.data)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def verify_email(email):
hunter = PyHunter(os.environ.get('HUNTER_API_KEY'))
try:
quality_score = hunter.email_verifier(email)
except HunterApiError:
return 0
return quality_score.get('score', 0)
def validate_email(self, email):
hunter_key = 'HUNTER_API_KEY'
hunter = PyHunter(hunter_key)
if hunter.email_verifier(email)['status'] not in ['valid','webmail']:
raise serializers.ValidationError('Invalid email address')
return email
def check_email_function(user_id):
user = User.objects.get(pk=user_id)
hunter = PyHunter(settings.PYHUNTER_TOKEN)
res = hunter.email_verifier(user.email)
# check result parameters here
if res['score'] > 10:
user.is_active = True
user.save()
def check_email(email):
# Check the deliverability of a given email adress by emailhunter.co
hunter = PyHunter(settings.EMAILHUNTER_API_KEY)
hunter_result = hunter.email_verifier(email)
if hunter_result and 'result' in hunter_result:
return hunter_result['result']
else:
return 'unchecked'
def register(usr):
hunter = PyHunter(config("HUNTER_KEY"))
mail = hunter.email_verifier(usr["email"])["webmail"]
if mail:
user = models.User()
user.first_name = usr["first_name"]
user.last_name = usr["last_name"]
user.email = usr["email"]
user.password = md5(usr["password"].encode()).hexdigest()
user.save()
def validate_email(self, value):
"""
Check if email exists
"""
if not settings.DEBUG_SIGNUP:
hunter = PyHunter(settings.HUNTER_API_KEY)
verification = hunter.email_verifier(value)
if verification['result'] == 'undeliverable':
raise ValidationError('Email address does not exist')
return value
def validate_email(value):
# Use emailhunter.co for verifying email existence on signup
py_hunter = PyHunter(settings.HUNTER_API_KEY)
if settings.HUNTER_ENABLED and settings.HUNTER_API_KEY:
if py_hunter.email_verifier(value).get(
'result') != 'undeliverable':
return value
raise serializers.ValidationError(
'An issue with email verification occures')
return value
def validate_email(self, email):
hunter = PyHunter(HUNTERIO_KEY)
try:
payload = hunter.email_verifier(email)
except Exception:
return
result = payload.get('result')
if result == 'undeliverable':
raise serializers.ValidationError(
'The email address is not valid.')
def _mail_verification(mail):
"""Mail validation via hunter site"""
try:
hunter = PyHunter(my_hunter_api_key)
user_data = hunter.email_verifier(mail)
# On risky & deliverable continue
if user_data['result'] == 'undeliverable':
raise Exception('Mail not approved')
return user_data
except Exception as e:
logging.warning(e)
return {e}
def emailVerifier(email):
print("email trouvé: ", email)
if email == None:
return False
else:
hunter = PyHunter('a890302fd13f718af83604989dbd3213772a0d07')
statut = hunter.email_verifier(email)['result']
print("statut: ", statut)
if statut == 'undeliverable':
return False
else:
return True
def verifylist(): for x in EMAILS: list = EMAILS hk = API_KEYS["hunter"] hunter = PyHunter(hk) h = hunter.email_verifier(x) if h["result"] == "undeliverable": Style.Colors.RB(x + " EMAIL RETURNED AN UNDELIVERABLE!") continue break else: Style.Colors.GB(x + " " + h["result"]) continue break
def check_email_hunter(email):
try:
# we could also use hunter.email_finder for get email list from domain and check is it include our email or not,
# but I see that we don't get all emails using this function and I decide dont't use it
verified = False
hunter = PyHunter(settings.HUNTERIO_API_KEY)
result = hunter.email_verifier(email)
if isinstance(result, dict) and result.get(
'webmail', False) and not result.get('block', True):
verified = True
except (ConnectionError, Timeout, HTTPError) as ex:
logger.error(f'Email hunter connection error {ex}')
return verified
def registration():
email = request.form['email']
first_name = request.form['first_name']
last_name = request.form['last_name']
password = request.form['password']
#checking for existing user
user = User.query.filter_by(email=email).first()
if user:
return {'success': False, 'msg': 'User already exists! Please Log in!'}
try:
#HUNTER
hunter = PyHunter('8a225ea7e524328c62224526b273d48266a41d65')
hunter.email_verifier(email)
#CLEARBIT
clearbit.key = 'sk_9910ef6078230afe0cf6460e59da8bf4'
user = clearbit.Person.find(email=email, stream=True)
'''if user != None:
user['some_parametar_for_get_data']'''
new_user = User(public_id=str(uuid.uuid4()),
email=email,
first_name=first_name,
last_name=last_name,
password=generate_password_hash(password))
db.session.add(new_user)
db.session.commit()
return {'success': True, 'msg': 'Successfully registered!'}
except:
return {
'success': False,
'msg': 'Registration failed, please try again!'
}
def email_verify(email):
"""
Check is email valid and is it deliverable
:param email: email to check
:return: True if email valid
:raise ValidationError if email invalid or undeliverable
"""
hunter = PyHunter(settings.HUNTER_API_KEY)
try:
response = hunter.email_verifier(email)
if response['result'] == 'undeliverable':
raise serializers.ValidationError
except exceptions.HTTPError:
raise serializers.ValidationError
return True
def post(self, request, format=None):
hunterAPI = '5aa57f6c3b4600d3a881a0d2b38e9311e5b91640'
email = request.data.get('email')
hunter = PyHunter(hunterAPI)
verify_email = hunter.email_verifier(email) #Checks if the email is deliverable or not through hunterAPI
if(verify_email.get('result')=='undeliverable'):
return Response({'status': 'Incorrect data',
'message': 'E-mail not deliverable'}, status=status.HTTP_400_BAD_REQUEST)
else:
if not request.data._mutable:
request.data._mutable = True
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
email = request.data['email']
hunter = PyHunter(settings.EMAILHUNTER_KEY)
clearbit.key = settings.CLEARBIT_KEY
valid = hunter.email_verifier(email)
content = dict(
valid=valid['result'],
)
person = clearbit.Person.find(email=email, stream=True)
if person is not None:
content.update(dict(
company=person['employment']['name'],
role=person['employment']['role'],
city=person['geo']['city'],
country=person['geo']['country'],
bio=person['bio'],
))
return Response(content)
def validate_email(self, email):
"""
Validate the email field.
:param email: The email.
:return: The email after validation
"""
if email is None:
raise serializers.ValidationError(
'Users must have an email address.')
# Verify email using hunter.io
hunter = PyHunter(settings.HUNTER_API_KEY)
result = hunter.email_verifier(email)
if result['status'] == 'invalid':
raise serializers.ValidationError(
'Users must have an valid email address.')
return email
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
email = serializer.validated_data['email']
# verify the deliverability of an email address
hunter = PyHunter(settings.EMAIL_HUNTER_API_KEY)
verify = hunter.email_verifier(email)
if not verify['gibberish'] and not verify['block']:
user = self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(self.get_response_data(user),
status=status.HTTP_201_CREATED,
headers=headers)
return Response(
{
'You use an automatically generated email address '
'or your email is blocked'
},
status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
# emailhunter.co for verifying email existence on signup
user_email = serializer.data['email']
hunter = PyHunter(settings.HUNTER_KEY)
if hunter.email_verifier(user_email)['result'] == 'undeliverable':
logger.warning(
'New user with invalid email was registered. Email: %s' %
user_email)
# I let the user with the undeliverable email to register because we have to implement bot for this task,
# otherwise we would have here:
# return Response(
# {'message': 'New user with invalid email tried to register. Email: %s' % user_email},
# status=status.HTTP_400_BAD_REQUEST)
else:
try:
clearbit.key = settings.CLEARBIT_KEY
person = clearbit.Person.find(email=user_email, stream=True)
except:
person = None
if person:
full_name = person['name']['fullName']
country = person['geo']['country']
else:
full_name = None
country = None
user = self.perform_create(serializer)
user_profile = UserProfile(user=user,
full_name=full_name,
country=country)
user_profile.save()
headers = self.get_success_headers(serializer.data)
logger.info('New user with email %s has been registered' %
user_email)
return Response(self.get_response_data(user),
status=status.HTTP_201_CREATED,
headers=headers)
hk = API_KEYS["hunter"]
menu.sub_3()
ek = input()
while ek != '0':
if ek == '1':
if not hk:
Style.Colors.RB("MISSING HUNTER API KEY. CANNOT COMPLETE THIS MODULE")
Style.RST()
break
else:
Style.Colors.C("ENTER AN EMAIL ADDRESS TO VERIFY")
Style.RST()
email = input()
x = email
hunter = PyHunter(hk)
h = hunter.email_verifier(x)
if h["result"] == "undeliverable":
Style.Colors.RB(x + "EMAIL RETURNED AN UNDELIVERABLE! \n\n" + h["result"])
else:
Style.Colors.GB(x + h["result"])
Style.RST()
break
if xkey == '4':
print('ENTER HOSTNAME TO SCAN AND GATHER DATA ON')
host = input()
shkey = API_KEYS["shodan_key"]
if not shkey:
Style.Colors.RB('\nMISSING SHODAN API KEY, RETURNING TO MAIN MENU')
Style.RST()
else:
def Search(Query_List, Task_ID, Type, Limit=10):
try:
Data_to_Cache = []
Directory = General.Make_Directory(Plugin_Name.lower())
logger = logging.getLogger()
logger.setLevel(logging.INFO)
Log_File = General.Logging(Directory, Plugin_Name.lower())
handler = logging.FileHandler(os.path.join(Directory, Log_File), "w")
handler.setLevel(logging.DEBUG)
formatter = logging.Formatter("%(levelname)s - %(message)s")
handler.setFormatter(formatter)
logger.addHandler(handler)
Shodan_API_Key = Load_Configuration()
API_Session = PyHunter(Shodan_API_Key)
Cached_Data_Object = General.Cache(Directory, Plugin_Name)
Cached_Data = Cached_Data_Object.Get_Cache()
Query_List = General.Convert_to_List(Query_List)
Limit = General.Get_Limit(Limit)
for Query in Query_List:
try:
if Type == "Domain":
if Common.Regex_Handler(Query, Type="Domain"):
Local_Plugin_Name = Plugin_Name + "-Domain"
API_Response = API_Session.domain_search(Query)
JSON_Object = Common.JSON_Handler(API_Response)
JSON_Output_Response = JSON_Object.Dump_JSON()
if API_Response["domain"] and API_Response['emails']:
Main_File = General.Main_File_Create(
Directory, Local_Plugin_Name,
JSON_Output_Response, Query,
The_File_Extensions["Main"])
Output_Connections = General.Connections(
Query, Local_Plugin_Name, Domain, "Account",
Task_ID, Plugin_Name.lower())
Current_Step = 0
for Hunter_Item in API_Response["emails"]:
Current_Email_Address = Hunter_Item["value"]
Current_Hunter_Item_Host = f"https://{Domain}/verify/{Current_Email_Address}"
Current_Hunter_Item_Responses = Common.Request_Handler(
Current_Hunter_Item_Host,
Filter=True,
Host=f"https://{Domain}")
Filtered_Response = Current_Hunter_Item_Responses[
"Filtered"]
Title = "Hunter | " + Current_Email_Address
if Current_Email_Address not in Cached_Data and Current_Email_Address not in Data_to_Cache and Current_Step < int(
Limit):
Output_file = General.Create_Query_Results_Output_File(
Directory, Query, Local_Plugin_Name,
Filtered_Response,
Current_Hunter_Item_Host,
The_File_Extensions["Query"])
if Output_file:
Output_Connections.Output(
[Main_File, Output_file],
Current_Hunter_Item_Host, Title,
Plugin_Name.lower())
Data_to_Cache.append(
Current_Email_Address)
else:
logging.warning(
f"{Common.Date()} - {__name__.strip('plugins.')} - Failed to create output file. File may already exist."
)
Current_Step += 1
elif Type == "Email":
if Common.Regex_Handler(Query, Type="Email"):
Local_Plugin_Name = Plugin_Name + "-Email"
API_Response = API_Session.email_verifier(Query)
JSON_Object = Common.JSON_Handler(API_Response)
JSON_Output_Response = JSON_Object.Dump_JSON()
if API_Response["email"] and API_Response['sources']:
Main_File = General.Main_File_Create(
Directory, Local_Plugin_Name,
JSON_Output_Response, Query,
The_File_Extensions["Main"])
Output_Connections = General.Connections(
Query, Local_Plugin_Name, Domain,
"Account Source", Task_ID, Plugin_Name.lower())
Current_Step = 0
for Hunter_Item in API_Response["sources"]:
Current_Hunter_Item_Host = Hunter_Item["uri"]
Current_Hunter_Item_Domain = Hunter_Item[
"domain"]
if 'http://' in Current_Hunter_Item_Host:
Current_Hunter_Item_Responses = Common.Request_Handler(
Current_Hunter_Item_Host,
Filter=True,
Host=
f"http://{Current_Hunter_Item_Domain}")
Filtered_Response = Current_Hunter_Item_Responses[
"Filtered"]
elif 'https://' in Current_Hunter_Item_Host:
Current_Hunter_Item_Responses = Common.Request_Handler(
Current_Hunter_Item_Host,
Filter=True,
Host=
f"https://{Current_Hunter_Item_Domain}"
)
Filtered_Response = Current_Hunter_Item_Responses[
"Filtered"]
else:
Filtered_Response = Common.Request_Handler(
Current_Hunter_Item_Host)
Title = "Hunter | " + Current_Hunter_Item_Host
if Current_Hunter_Item_Host not in Cached_Data and Current_Hunter_Item_Host not in Data_to_Cache and Current_Step < int(
Limit):
Output_file = General.Create_Query_Results_Output_File(
Directory, Query, Local_Plugin_Name,
Filtered_Response,
Current_Hunter_Item_Host,
The_File_Extensions["Query"])
if Output_file:
Output_Connections.Output(
[Main_File, Output_file],
Current_Hunter_Item_Host, Title,
Plugin_Name.lower())
Data_to_Cache.append(
Current_Hunter_Item_Host)
else:
logging.warning(
f"{Common.Date()} - {__name__.strip('plugins.')} - Failed to create output file. File may already exist."
)
Current_Step += 1
except Exception as e:
logging.warning(
f"{Common.Date()} - {__name__.strip('plugins.')} - Failed to complete task - {str(e)}"
)
Cached_Data_Object.Write_Cache(Data_to_Cache)
except Exception as e:
logging.warning(
f"{Common.Date()} - {__name__.strip('plugins.')} - {str(e)}")
def verify_email(user):
hunter = PyHunter(settings.HUNTER_KEY)
response = hunter.email_verifier(user.email)
if response['regexp'] and response['smtp_check']:
user.verified_email = True
user.save(update_fields=['verified_email'])
def main():
linkedin_username = os.getenv("LINKEDIN_USER")
linkedin_passkey = os.getenv("LINKEDIN_PASS")
hunter_apikey = os.getenv("HUNTER_API")
chromedriver_dir = os.getenv("CHROMEDRIVER")
listing_url = input(
"Welcome to Recruit_Link! Please enter a job listing's LinkedIn url:\n"
)
name, title, profile, company, company_website, job_title = \
find_contact(listing_url, linkedin_username, linkedin_passkey, chromedriver_dir)
company_website = company_website.replace("bit.ly",
f"{company}.com").replace(
"/careers", "")
print(f"Now searching for: {name.strip()}, {title.strip()}\n")
email_message = f"Hi {name.split()[0]},\n" \
f"\n" \
f"I hope this email finds you well. I just recently saw a posting for a {job_title} position at {company}" \
f" and would love to learn more. My experience with Python, SQL, SKILLS HERE feels like a great fit for " \
f"the role.\n" \
f"\n" \
f"Could you tell me more about the data science team and what it's like to work for the company? " \
f"I believe you would have great insight as a {title.strip()} for {company}.\n" \
f"\n" \
f"I appreciate any information you could provide, looking forward to hearing from you!\n" \
f"\n" \
f"Thank you,\n" \
f"\n"
linkedin_message = f"Hi {name.split()[0]}, I recently saw a {job_title} position at {company} and I wanted " \
f"to learn more about your company! My experience with Python, SQL, FILL feels like a great fit " \
f"for the role. Would love any more information you have, thanks!"
name = name.lower()
company_email = company_website.replace("https://www.", "@")\
.replace("http://www.", "@")\
.replace("http:", "@")\
.replace("https:", "@")\
.replace("jobs.", "")\
.replace(r"\.com.*$", ".com")\
.replace("/", "")
patterns = [
"finitiallast", "finitial.last", "firstlast", "first.last", "first",
"last", "firstlinitial", "first.linitial", "first_linitial",
"finitial_last"
]
patterns = [
pattern.replace("first",
name.split()[0]).replace(
"last",
name.split()[-1]).replace(
"finitial",
name.split()[0][0]).replace(
"linitial",
name.split()[-1][0]) + company_email
for pattern in patterns
]
hunter = PyHunter(hunter_apikey) # Hunter API Key here
hunter_email, confidence_score = hunter.email_finder(company_website,
full_name=name)
if hunter_email:
emails = [hunter_email] + patterns
else:
emails = patterns
for email in emails:
print(f"Checking {email}...")
try:
verification = hunter.email_verifier(email)
except:
continue
if verification['result'] == 'deliverable':
print("Success, found the following email:\n")
print(email)
pyperclip.copy(email_message)
print("Message pasted to clipboard.")
exit()
elif email == emails[-1]:
print(f"Email search failed, try to contact on LinkedIn:\n"
f"{profile}")
pyperclip.copy(linkedin_message)
print("Message pasted to clipboard.")
exit()
else:
continue
def check_email(email):
hunter = PyHunter(os.getenv("HUNTER_API"))
result = hunter.email_verifier(email)
return result['webmail']
url = x
print(url)
results = hunter.domain_search(url)
printed = json.dumps(results)
fopen.write(printed)
fopen.close()
elif (args.fns):
company1 = input("Enter company of interest..")
name = input("Enter person of interest")
results = hunter.email_finder(company=company1, full_name=name, raw=True)
print(results)
elif (args.v):
validatepls = input("File with Email addresses to validate..")
outfile = input("Location of output text file..")
fopen = open(outfile, 'w')
with open(validatepls) as f:
for i in f:
x = i.rstrip('\n')
print(x)
emailname = x
print(emailname)
validated = hunter.email_verifier(emailname)
printed = json.dumps(validated)
fopen.write(emailname)
fopen.write('\n')
fopen.write(printed)
fopen.close()
elif (args.c):
number_left = hunter.account_information()
print(number_left)
def post(self, request, *args, **kwargs):
username = request.data.get("username", "")
password = request.data.get("password", "")
email = request.data.get("email", "")
first_name = request.data.get("first_name", "")
last_name = request.data.get("last_name", "")
if not username and not password and not email:
return Response(data={
"message":
"username, password and email is required to register a user"
},
status=status.HTTP_400_BAD_REQUEST)
try:
validate_email(email)
except ValidationError as e:
return Response(
data={"message": "please provide proper email address"},
status=status.HTTP_400_BAD_REQUEST)
try:
validate_password(
password,
password_validators=[MinimumLengthValidator(min_length=6)])
except ValidationError as e:
return Response(
data={"message": "password length should be 6 or longer"},
status=status.HTTP_400_BAD_REQUEST)
try:
hunter = PyHunter(EMAILHUNTER_API_KEY)
email_verifier = hunter.email_verifier(email)
if (not email_verifier
or email_verifier['result'] == 'undeliverable'):
return Response(data={
"message":
"email address: {} is not deliverable".format(email)
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return Response(data={"message": e.args[0]},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
try:
new_user = User.objects.create_user(username=username,
password=password,
email=email,
first_name=first_name,
last_name=last_name)
except IntegrityError as e:
if 'UNIQUE constraint' in e.args[0]:
return Response(data={
"message":
"username {} already exists".format(username)
},
status=status.HTTP_409_CONFLICT)
try:
clearbit.key = CLEARBIT_API_KEY
profile_data_clearbit = clearbit.Enrichment.find(email=email,
stream=True)
except Exception as e:
return Response(data={"message": e.args[0]},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
if profile_data_clearbit and 'person' in profile_data_clearbit:
new_user.profile.bio = profile_data_clearbit['person']['bio']
new_user.profile.site = profile_data_clearbit['person']['site']
new_user.profile.location = profile_data_clearbit['person'][
'location']
new_user.profile.timezone = profile_data_clearbit['person'][
'timeZone']
new_user.profile.utc_offset = profile_data_clearbit['person'][
'utcOffset']
new_user.profile.company_name = profile_data_clearbit['person'][
'employment']['name']
new_user.profile.company_role = profile_data_clearbit['person'][
'employment']['role']
new_user.profile.facebook_handle = profile_data_clearbit['person'][
'facebook']['handle']
new_user.profile.twitter_handle = profile_data_clearbit['person'][
'twitter']['handle']
new_user.profile.github_handle = profile_data_clearbit['person'][
'github']['handle']
new_user.profile.linkedin_handle = profile_data_clearbit['person'][
'linkedin']['handle']
new_user.profile.googleplus_handle = profile_data_clearbit[
'person']['googleplus']['handle']
new_user.save()
return Response(data=UserSerializer(new_user).data,
status=status.HTTP_201_CREATED)
categories = []
data = []
# NanData = ['noEmail']*12 + [[]]
# verify2 = hunter.email_verifier('*****@*****.**') # len=13
# To populate the dataframe we are just going to iterate through the dictionary
# If sources are empty, then pass,else iterate through sources
hunterInfo = pd.DataFrame(columns=['result','score', 'Email','regexp','gibberish',
'disposable','webmail','mx_records','smtp_server',
'smtp_check','accept_all','block','sources'])
total= len(temp_list)
counter = 0
for email in temp_list:
counter += 1
print('{}/{}'.format(counter,total))
print('Verifying {}...'.format(email))
verify_dict = hunter.email_verifier(email)
for items in verify_dict.items():
# print(items)
# print(type(items[0]))
# categories.append(items[0])
data.append(items[1])
hunterInfo.loc[len(hunterInfo)] = data
data = []
'''
for emails in email_list:
verify_dict=email_verifier(emails)
source = verify_dict['sources']
if not source:
'no source'