├── .gitignore
├── functions
    ├── __init__.py
    ├── http.py
    ├── hunterio.py
    ├── rocketreach.py
    └── generic.py
├── requirements.txt
├── settings.py
├── README.md
└── peopleScrap.py


/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | *.pyo
3 | settings.py
4 | 


--------------------------------------------------------------------------------
/functions/__init__.py:
--------------------------------------------------------------------------------
1 | __all__ = ["generic","rocketreach"]
2 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | requests==2.21.0
2 | tabulate==0.8.2
3 | Unidecode==1.0.23
4 | 


--------------------------------------------------------------------------------
/settings.py:
--------------------------------------------------------------------------------
 1 | #### Set API keys here
 2 | # RocketReach
 3 | ROCKETREACH_API_KEY=""
 4 | # HunterIO
 5 | HUNTERIO_API_KEY=""
 6 | 
 7 | #### Some constants
 8 | # Web/requests
 9 | USER_AGENT="Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0"
10 | DEFAULT_WAIT=2
11 | DEFAULT_TIMEOUT=3
12 | 
13 | ### API
14 | # RocketReach
15 | ROCKETREACH_ACCOUNT_URL="https://api.rocketreach.co/v1/api/account"
16 | ROCKETREACH_SEARCH_URL="https://api.rocketreach.co/v1/api/search"
17 | ROCKETREACH_STATUS_URL="https://api.rocketreach.co/v1/api/checkStatus"
18 | ROCKETREACH_LOOKUP_URL="https://api.rocketreach.co/v1/api/lookupProfile"
19 | # HunterIO
20 | HUNTERIO_ACCOUNT_URL="https://api.hunter.io/v2/account"
21 | HUNTERIO_DOMAIN_URL="https://api.hunter.io/v2/domain-search"
22 | 
23 | # Color
24 | GREEN="\033[0;32m"
25 | RED="\033[0;31m"
26 | ORANGE="\033[0;33m"
27 | NOCOLOR="\033[0m"
28 | 
29 | # Global variables
30 | def init_datalist():
31 |     global PEOPLE_DATA
32 |     PEOPLE_DATA = []
33 | 


--------------------------------------------------------------------------------
/functions/http.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | import json
 3 | from settings import *
 4 | 
 5 | # Get JSON loaded data from HTTP GET request
 6 | def http_get_json(HTTP_REQ):
 7 |     req = http_get(HTTP_REQ)
 8 |     if req != None:
 9 |         http_code = req.status_code
10 |         try: # Try and parse JSON data
11 |             json_data = json.loads(req.content)
12 |             return http_code, json_data
13 |         except ValueError as e:
14 |             return http_code, e
15 |     return None, None
16 | 
17 | # Perform HTTP query
18 | def http_get(HTTP_REQ):
19 |     # Define headers
20 |     headers = {
21 |         "User-Agent": "%s" % (HTTP_REQ["user-agent"]),
22 |         "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
23 |         "Accept_language": "en-US,en;q=0.5",
24 |         "Accept_encoding": "gzip, deflate, br"
25 |     }
26 | 
27 |     try:
28 |         return requests.get(HTTP_REQ["url"], headers=headers, proxies=HTTP_REQ["proxy"], timeout=HTTP_REQ["timeout"])
29 |     except requests.exceptions.ConnectionError as e:
30 |         print("[!] No connection to the Internet")
31 |     except requests.exceptions.HTTPError as e:
32 |         print("[!] Exception while performing HTTP request to %s" % (HTTP_REQ["url"]))
33 |     except requests.exceptions.ReadTimeout as e:
34 |         print("[!] Timeout while performing HTTP request to %s" % (HTTP_REQ["url"]))
35 | 
36 |     return None
37 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # PeopleScrap
 2 | 
 3 | PeopleScrap helps gathering information about people in a company (i.e.: mycompany) or domain (i.e.: mycompany.com).
 4 | 
 5 | ### Features
 6 | - Find emails, first name, last name, job position, city/location, phone numbers, etc.
 7 | - Uses RocketReach & Hunter.io APIs to gather information
 8 | - Generate emails according to user's choice
 9 | - Output result to CSV file
10 | - Developped in Python3
11 | - Handle user interruption (in case of network issues) and display current results anyway
12 | 
13 | ### Installation
14 | * Install Python3 dependencies
15 | ```
16 | pip3 install --user -r requirements.txt
17 | ```
18 | * Set up your API keys in "settings.py"
19 | * Run
20 | ```
21 | ./peopleScrap.py
22 | ```
23 | 
24 | ### Usage
25 | ```
26 |  _____                 _       _____                      
27 | |  __ \               | |     / ____|                     
28 | | |__) |__  ___  _ __ | | ___| (___   ___ _ __ __ _ _ __  
29 | |  ___/ _ \/ _ \| '_ \| |/ _ \___ \  / __| '__/ _` | '_ \ 
30 | | |  |  __/ (_) | |_) | |  __/____) | (__| | | (_| | |_) |
31 | |_|   \___|\___/| .__/|_|\___|_____/ \___|_|  \__,_| .__/ 
32 |                 | |                                | |    
33 |                 |_|                                |_|    
34 | 
35 | usage: peopleScrap.py [-h] [-c company] [-d domain] [-l] [-o <file>]
36 |                       [--wait <time>] [--timeout <time>] [--user <user-agent>]
37 |                       [--proxy <proxy>] [--nocheck]
38 | 
39 | Python utility to query RocketReach API
40 | 
41 | optional arguments:
42 |   -h, --help           show this help message and exit
43 |   -c company           Search people in company (i.e.: mycompany)
44 |   -d domain            Search people in domain (i.e.: mycompany.com)
45 |   -l                   Perform lookup search (i.e.: emails)
46 |   -o <file>            Output results to file (csv), beware as it will overwrite any data in file
47 |   --wait <time>        Time to wait between requests (default: 2s.)
48 |   --timeout <time>     Timeout for HTTP requests (default: 3s.)
49 |   --user <user-agent>  Change default user-agent (default: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0)
50 |   --proxy <proxy>      Proxy to perform HTTP requests (ie.: http://localhost:8080, socks5://localhost:8080)
51 |   --nocheck            Do not perform API checks
52 | ```
53 | 
54 | ### ToDo
55 | - Finish lookup (RocketReach)
56 | - Try to sort|uniq results
57 | - Add LinkedIn (API or website)
58 | 


--------------------------------------------------------------------------------
/peopleScrap.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | import sys
  3 | from signal import signal, SIGINT
  4 | from argparse import ArgumentParser, RawTextHelpFormatter
  5 | 
  6 | import settings
  7 | from functions.generic import *
  8 | from functions.rocketreach import *
  9 | from functions.hunterio import *
 10 | 
 11 | # SIGINT handler
 12 | def interruptHandler(signal, frame):
 13 |     display_people()
 14 |     exiting("Interrupted by user.")
 15 | 
 16 | # Parse arguments
 17 | def parse_args():
 18 |     parser = ArgumentParser(description="Python utility to query RocketReach API", formatter_class=RawTextHelpFormatter)
 19 |     parser.add_argument("-c", required=False, metavar="company", help="Search people in company (i.e.: mycompany)")
 20 |     parser.add_argument("-d", required=False, metavar="domain", help="Search people in domain (i.e.: mycompany.com)")
 21 |     parser.add_argument("-l", required=False, action="store_true", help="Perform lookup search (i.e.: emails)")
 22 |     parser.add_argument("-o", required=False, metavar="<file>", help="Output results to file (csv), beware as it will overwrite any data in file")
 23 | 
 24 |     parser.add_argument("--wait", required=False, metavar="<time>", default=DEFAULT_WAIT, type=int, help="Time to wait between requests (default: %ss.)" % DEFAULT_WAIT)
 25 |     parser.add_argument("--timeout", required=False, metavar="<time>", default=DEFAULT_TIMEOUT, type=int, help="Timeout for HTTP requests (default: %ss.)" % DEFAULT_TIMEOUT)
 26 |     parser.add_argument("--user", required=False, metavar="<user-agent>", default=USER_AGENT, help="Change default user-agent (default: %s)" % USER_AGENT)
 27 |     parser.add_argument("--proxy", required=False, metavar="<proxy>", default="", help="Proxy to perform HTTP requests (ie.: http://localhost:8080, socks5://localhost:8080)")
 28 |     parser.add_argument("--nocheck", required=False, action="store_true", help="Do not perform API checks")
 29 |     args = parser.parse_args()
 30 | 
 31 |     if not (args.c or args.d):
 32 |         print("[!] %s requires a company name (-c) or company domain (-d)\nExiting..." % (sys.argv[0]))
 33 |         sys.exit(1)
 34 |     return args
 35 | 
 36 | # Main function
 37 | def main(args):
 38 |     # Set HTTP_REQ
 39 |     HTTP_REQ = {}
 40 |     HTTP_REQ["user-agent"] = args.user
 41 |     HTTP_REQ["proxy"] = {} if (len(args.proxy) == 0) else {"https": args.proxy, "http": args.proxy}
 42 |     HTTP_REQ["wait"] = args.wait # Default wait time or user selected value
 43 |     HTTP_REQ["timeout"] = args.timeout # Default timeout or user selected value
 44 | 
 45 |     # Display some info
 46 |     print("[*] Options")
 47 |     if (args.o):
 48 |         print(" - Output file: \"%s\"" % (args.o))
 49 |     print(" - User-Agent: %s" % (HTTP_REQ["user-agent"]))
 50 |     print(" - Proxy: %s" % (HTTP_REQ["proxy"]))
 51 |     print(" - Wait: %ss." % (HTTP_REQ["wait"]))
 52 |     print(" - Timeout: %ss.\n" % (HTTP_REQ["timeout"]))
 53 | 
 54 |     # Perform some checks to ensure RocketReach's API key is ok
 55 |     if not args.nocheck:
 56 |         rocketReach_checks(HTTP_REQ)
 57 |         hunterIO_checks(HTTP_REQ)
 58 |     else:
 59 |         print("[*] Not performing API checks")
 60 | 
 61 |     input("""\nSearching for people in company: \"%s\" and/or domain: \"%s\"\npress any key to continue...\n""" %
 62 |         ("" if args.c == None else args.c, "" if args.d == None else args.d))
 63 | 
 64 |     # RocketReach
 65 |     if (args.c): # If a company name was provided
 66 |         rocketReach_fetch_people_from_company(HTTP_REQ, args.c)
 67 | 
 68 |     # HunterIO
 69 |     possible_mail_pattern = ""
 70 |     if (args.d): # If a company domain was provided
 71 |         possible_mail_pattern = hunterIO_fetch_domain_info(HTTP_REQ, args.d)
 72 | 
 73 |     if (args.c and args.l): # Perform lookup
 74 |         rocketReach_lookup_people(HTTP_REQ)
 75 | 
 76 |     # Ask user for pattern validation
 77 |     if ask_for_mail_pattern():
 78 |         find_mail_pattern(possible_mail_pattern, args.d)
 79 | 
 80 |     print("\n[*] Total people found: %d" % (len(settings.PEOPLE_DATA)))
 81 |     input("\npress any key to continue...\n")
 82 | 
 83 |     # Display to user
 84 |     print("\n[*] Now displaying info to user: \n")
 85 |     display_people()
 86 | 
 87 |     # Write output to file
 88 |     if (args.o):
 89 |         write_people(args.o)
 90 | 
 91 | # Starts here
 92 | if __name__ == "__main__":
 93 |     print(" _____                 _       _____                      ")
 94 |     print("|  __ \               | |     / ____|                     ")
 95 |     print("| |__) |__  ___  _ __ | | ___| (___   ___ _ __ __ _ _ __  ")
 96 |     print("|  ___/ _ \/ _ \| '_ \| |/ _ \\___ \  / __| '__/ _` | '_ \ ")
 97 |     print("| |  |  __/ (_) | |_) | |  __/____) | (__| | | (_| | |_) |")
 98 |     print("|_|   \___|\___/| .__/|_|\___|_____/ \___|_|  \__,_| .__/ ")
 99 |     print("                | |                                | |    ")
100 |     print("                |_|                                |_|    ")
101 |     print()
102 |     signal(SIGINT, interruptHandler)
103 |     args = parse_args()
104 |     init_datalist()
105 |     # Main
106 |     main(args)
107 | 


--------------------------------------------------------------------------------
/functions/hunterio.py:
--------------------------------------------------------------------------------
  1 | # coding=utf-8
  2 | from tabulate import tabulate
  3 | from time import sleep
  4 | 
  5 | import settings
  6 | from functions.http import *
  7 | from functions.generic import *
  8 | 
  9 | OFFSET_VALUE=100
 10 | INSUFFICIENT_CREDS=0
 11 | MAX_INSUFFICIENT_CREDS=3
 12 | 
 13 | ### API calls
 14 | def hunterIO_call_account(HTTP_REQ):
 15 |     HTTP_REQ["url"] = "%s?api_key=%s" % (HUNTERIO_ACCOUNT_URL, HUNTERIO_API_KEY)
 16 |     http_code, response = http_get_json(HTTP_REQ)
 17 |     return response
 18 | 
 19 | def hunterIO_call_domain_search(HTTP_REQ, domain, offset=0, limit=100):
 20 |     HTTP_REQ["url"] = "%s?api_key=%s&domain=%s&offset=%d&limit=%d" % (HUNTERIO_DOMAIN_URL, HUNTERIO_API_KEY, domain, offset, limit)
 21 |     http_code, response = http_get_json(HTTP_REQ)
 22 |     hunterIO_check_limit(response)
 23 |     return response
 24 | ### /API calls
 25 | 
 26 | # Parsing
 27 | def hunterIO_parse_info(data):
 28 |     # Get emails
 29 |     emails = dict_check_and_get(data, "emails")
 30 |     if emails != None:
 31 |         for e in emails:
 32 |             # Maybe try to clear doublon, based on emails and/or name?
 33 |             p = People()
 34 |             p.parse_from_hunterIO(dict_check_and_get(e, "first_name"), dict_check_and_get(e, "last_name"),
 35 |                 dict_check_and_get(e, "value"), dict_check_and_get(e, "phone_number"), dict_check_and_get(e, "twitter"))
 36 |             settings.PEOPLE_DATA.append(p)
 37 | 
 38 | def hunterIO_fetch_domain_info(HTTP_REQ, domain):
 39 |     # Get data
 40 |     print("\n[*] HunterIO - Starting...")
 41 |     current_offset = OFFSET_VALUE
 42 |     json_data = hunterIO_call_domain_search(HTTP_REQ, domain) # Default offset = 0
 43 |     ret_pattern = ""
 44 | 
 45 |     # Get data
 46 |     data = dict_check_and_get(json_data, "data")
 47 |     if data != None:
 48 |         print("[*] HunterIO - Info")
 49 |         display_value_from_dict(data, "webmail", " - Webmail: ")
 50 |         display_value_from_dict(data, "pattern", " - Mail pattern: ")
 51 |         ret_pattern = dict_check_and_get(data, "pattern")
 52 |         display_value_from_dict(data, "organization", " - Organization: ")
 53 |         # Parse info
 54 |         hunterIO_parse_info(data)
 55 | 
 56 |     # Get meta
 57 |     meta = dict_check_and_get(json_data, "meta")
 58 |     if meta != None:
 59 |         total_people = dict_check_and_get(meta, "results")
 60 |         display_value_from_dict(meta, "results", " - results: ")
 61 |         display_value_from_dict(meta, "limit", " - limit: ")
 62 |         # Loop and fetch people
 63 |         while total_people > current_offset:
 64 |             print("[*] HunterIO - People: %d - %d" % (current_offset, total_people))
 65 |             # Query (offset)
 66 |             json_data = hunterIO_call_domain_search(HTTP_REQ, domain, offset=current_offset)
 67 |             # Parse info
 68 |             data = dict_check_and_get(json_data, "data")
 69 |             if data != None:
 70 |                 hunterIO_parse_info(data)
 71 | 
 72 |             if (INSUFFICIENT_CREDS > MAX_INSUFFICIENT_CREDS):
 73 |                 print("[!] Insufficient lookup credits, aborting lookup search...")
 74 |                 break
 75 |             current_offset += OFFSET_VALUE
 76 |             break
 77 |     print("[*] HunterIO - Done!")
 78 |     return ret_pattern
 79 | 
 80 | # Display info about account related to API key
 81 | def hunterIO_display_account_info(data_info):
 82 |     print("*** HunterIO account info ***")
 83 |     display_value_from_dict(data_info, "email", " - Email: ")
 84 |     display_value_from_dict(data_info, "plan_name", " - Account type: ")
 85 |     display_value_from_dict(data_info, "reset_date", " - Reset date: ")
 86 |     display_value_from_dict(data_info, "calls", " - Calls: ")
 87 | 
 88 | def hunterIO_check_limit(json_data):
 89 |     global INSUFFICIENT_CREDS
 90 |     #{'errors': [{'id': 'too_many_requests', 'code': 429, 'details': "You've exceeded your monthly limit. Please upgrade your account."}]}
 91 |     errors = dict_check_and_get(json_data, "errors")
 92 |     if errors != None:
 93 |         errors = errors[0]
 94 |         details = dict_check_and_get(errors, "details")
 95 |         if "You've exceeded your monthly limit" in details:
 96 |             print("[!] HunterIO | %s" % details)
 97 |             INSUFFICIENT_CREDS+=1
 98 | 
 99 | # Check accounts (calls /account)
100 | def hunterIO_check_account(HTTP_REQ):
101 |     result = hunterIO_call_account(HTTP_REQ)
102 |     if result != None:
103 |         errors = dict_check_and_get(result, "errors")
104 |         if errors != None: # Not good
105 |             details =  dict_check_and_get(errors[0], "details")
106 |             print("[!] HunterIO | Error: %s " % details)
107 |         else:
108 |             data = dict_check_and_get(result, "data")
109 |             hunterIO_display_account_info(data)
110 |             return 1
111 |     return 0
112 | 
113 | # Check if an API key has been set by user
114 | def hunterIO_check_basic():
115 |     if HUNTERIO_API_KEY != "":
116 |         return 1
117 |     else:
118 |         return 0
119 | 
120 | # Perform checks
121 | def hunterIO_checks(HTTP_REQ):
122 |     print("\n[*] HunterIO: Checking API key\n")
123 |     if not (hunterIO_check_basic() and hunterIO_check_account(HTTP_REQ)):
124 |         print("[!] HunterIO | Error while checking HunterIO API key (please provide a valid API key)")
125 | 


--------------------------------------------------------------------------------
/functions/rocketreach.py:
--------------------------------------------------------------------------------
  1 | # coding=utf-8
  2 | from time import sleep
  3 | 
  4 | import settings
  5 | from functions.http import *
  6 | from functions.generic import *
  7 | 
  8 | INSUFFICIENT_CREDS=0
  9 | MAX_INSUFFICIENT_CREDS=3
 10 | 
 11 | ### API calls
 12 | def rocketReach_call_account(HTTP_REQ):
 13 |     HTTP_REQ["url"] = "%s?api_key=%s" % (ROCKETREACH_ACCOUNT_URL, ROCKETREACH_API_KEY)
 14 |     http_code, response = http_get_json(HTTP_REQ)
 15 |     return response
 16 | 
 17 | def rocketReach_call_search(HTTP_REQ, company, page_start=1,page_size=100):
 18 |     HTTP_REQ["url"] = "%s?api_key=%s&company=%s&page_size=%d&start=%d" % (ROCKETREACH_SEARCH_URL, ROCKETREACH_API_KEY, company, page_size, page_start)
 19 |     pagination, response = None, None
 20 |     http_code, response = http_get_json(HTTP_REQ)
 21 |     if response != None:
 22 |         pagination = dict_check_and_get(response, "pagination")
 23 |     return pagination, response
 24 | 
 25 | def rockeyReach_call_lookup(HTTP_REQ, id):
 26 |     global INSUFFICIENT_CREDS
 27 |     HTTP_REQ["url"] = "%s?api_key=%s&id=%s" % (ROCKETREACH_LOOKUP_URL, ROCKETREACH_API_KEY, id)
 28 |     http_code, response = http_get_json(HTTP_REQ)
 29 |     detail = dict_check_and_get(response, "detail")
 30 |     if detail != None:
 31 |         print("[!] %s" % detail)
 32 |         if "You have insufficient lookup credits." in detail:
 33 |             INSUFFICIENT_CREDS+=1
 34 |     else:
 35 |         if len(response):
 36 |             status = dict_check_and_get(response[0], "status")
 37 |             if status != "complete":
 38 |                 print("Status: %s (id:%d)" % (status, id))
 39 |             return response
 40 |     return None
 41 | ### /API calls
 42 | 
 43 | # Parsing
 44 | def rocketreach_parse_people(json_data):
 45 |     profiles = dict_check_and_get(json_data, "profiles")
 46 |     if profiles != None: # Error while parsing profiles
 47 |         for profile in profiles:
 48 |             p = People()
 49 |             p.parse_from_rocketReach(dict_check_and_get(profile, "name"), dict_check_and_get(profile, "current_title"),
 50 |                 dict_check_and_get(profile, "current_employer"), dict_check_and_get(profile, "city"),
 51 |                 dict_check_and_get(profile, "country_code"), dict_check_and_get(profile, "id"),
 52 |                 dict_check_and_get(profile, "status"))
 53 |             settings.PEOPLE_DATA.append(p)
 54 | 
 55 | def rocketReach_fetch_people_from_company(HTTP_REQ, company):
 56 |     # Get data
 57 |     print("\n[*] RocketReach - Starting...")
 58 |     pagination, data  = rocketReach_call_search(HTTP_REQ, company)
 59 |     display_value_from_dict(pagination, "total", "[*] RocketReach - Total people: ")
 60 |     # Parse data (if only one page)
 61 |     rocketreach_parse_people(data)
 62 |     # Iterate over page(s), if necessary
 63 |     current_page = dict_check_and_get(pagination, "thisPage")
 64 |     next_page = dict_check_and_get(pagination, "nextPage")
 65 |     while current_page != next_page:
 66 |         print("[*] RocketReach - People: %d - %d" % (current_page, next_page))
 67 |         pagination, data = rocketReach_call_search(HTTP_REQ, company, next_page)
 68 |         rocketreach_parse_people(data)
 69 |         # Get pagination
 70 |         current_page = dict_check_and_get(pagination, "thisPage")
 71 |         next_page = dict_check_and_get(pagination, "nextPage")
 72 |     print("[*] RocketReach - Done!")
 73 | 
 74 | # Perform lookup (search for more information about people)
 75 | def rocketReach_lookup_people(HTTP_REQ):
 76 |     global INSUFFICIENT_CREDS
 77 |     print("\n[*] Gathering information (lookup)")
 78 |     lookup_people = [p for p in settings.PEOPLE_DATA if (p.rocket_id != None and p.rocket_id != "")]
 79 |     print("[*] %d people with a RocketReach ID" % (len(lookup_people)))
 80 |     for p in lookup_people:
 81 |         result_lookup = rockeyReach_call_lookup(HTTP_REQ, p.rocket_id)
 82 | 
 83 |         if result_lookup != None:
 84 |             print(result_lookup)
 85 | 
 86 |             print("Size of response lookup: %s" % (len(result_lookup)))
 87 |             result_lookup = result_lookup[0]
 88 | 
 89 |             # Personal and work emails
 90 |             properly_add_to_list(p.emails, dict_check_and_get(result_lookup, "current_work_email"))
 91 |             properly_add_to_list(p.emails, dict_check_and_get(result_lookup, "current_personal_email"))
 92 | 
 93 |             list_emails = dict_check_and_get(result_lookup, "emails")
 94 |             if (list_emails != None):
 95 |                 for e in list_emails:
 96 |                     properly_add_to_list(p.emails, dict_check_and_get(e, "email"))
 97 | 
 98 |             list_phones = dict_check_and_get(result_lookup, "phones")
 99 |             if (list_phones != None):
100 |                 for p in list_phones:
101 |                     properly_add_to_list(p.phones, p)
102 | 
103 |         if (INSUFFICIENT_CREDS > MAX_INSUFFICIENT_CREDS):
104 |             print("[!] Insufficient lookup credits, aborting lookup search...")
105 |             break
106 | 
107 |         # Wait 1 second - prevent throttling
108 |         sleep(1.2)
109 | 
110 | # Display info about account related to API key
111 | def rocketReach_display_account_info(data_info):
112 |     print("*** RocketReach account info ***")
113 |     display_value_from_dict(data_info, "email", " - Email: ")
114 |     display_value_from_dict(data_info, "lookup_credit_balance", " - Available lookup credit: ")
115 |     display_value_from_dict(data_info, "plan", " - Account type: ")
116 | 
117 | # Checks
118 | def rocketReach_check_account(HTTP_REQ):
119 |     result = rocketReach_call_account(HTTP_REQ)
120 |     if result != None:
121 |         detail = dict_check_and_get(result, "detail")
122 |         if detail != None: # Not good
123 |             print("[!] RocketReach | %s " % detail)
124 |         else:
125 |             rocketReach_display_account_info(result)
126 |             return 1
127 |     return 0
128 | 
129 | # Check if an API key has been set by user
130 | def rocketReach_check_basic():
131 |     if ROCKETREACH_API_KEY != "":
132 |         return 1
133 |     else:
134 |         return 0
135 | 
136 | # Perform checks
137 | def rocketReach_checks(HTTP_REQ):
138 |     print("\n[*] RocketReach: Checking API key\n")
139 |     if not (rocketReach_check_basic() and rocketReach_check_account(HTTP_REQ)):
140 |         print("[!] RocketReach | Error while checking RocketReach API key (please provide a valid API key)")
141 | 


--------------------------------------------------------------------------------
/functions/generic.py:
--------------------------------------------------------------------------------
  1 | import sys
  2 | import settings
  3 | from tabulate import tabulate
  4 | from unidecode import unidecode
  5 | 
  6 | MAX_CHARS=80
  7 | MAIL_PATTERNS = [(1, "{first}.{last}"), (2, "{f}.{last}"), (3, "{first}{last}"), (4, "{first}-{last}"), (5, "{f}{last}"), (6, "{first}")]
  8 | 
  9 | # Check if value is in given dictionary or return None
 10 | def dict_check_and_get(d, value):
 11 |     if d == None:
 12 |         return None
 13 |     else:
 14 |         return d[value] if value in d else None
 15 | 
 16 | def display_value_from_dict(d, value, pre="", post=""):
 17 |     result = dict_check_and_get(d, value)
 18 |     if result != None:
 19 |         print("%s%s%s" % (pre, result, post))
 20 | 
 21 | def write_to_file(output_file, mode, data):
 22 |     with open(output_file, mode) as fout:
 23 |         fout.write("%s\n" % (data))
 24 | 
 25 | # Parse JSON result
 26 | def parse_json(data, needed):
 27 |     g = list()
 28 |     for d in data:
 29 |         l = list()
 30 |         for n in needed:
 31 |             l.append(check_and_get(d, n))
 32 |         g.append(l)
 33 |     return g
 34 | 
 35 | def split_long_string(string, max_len):
 36 |     if (string != None) and (len(string) > max_len):
 37 |         return "\n".join([string[i:i+max_len] for i in range(0, len(string), max_len)])
 38 |     else:
 39 |         return string
 40 | 
 41 | def properly_add_to_list(m_list, value):
 42 |     if value != None:
 43 |         if value not in m_list:
 44 |             m_list.append(value)
 45 | 
 46 | # Ask user whether to generate mail pattern or not
 47 | def ask_for_mail_pattern():
 48 |     print("\n[*] Mail pattern")
 49 |     while True:
 50 |         response = input("   Do you want to generate mail pattern (y/n)? ")
 51 |         if response.lower() == "y":
 52 |             return 1
 53 |         elif response.lower() == "n":
 54 |             return 0
 55 |         else:
 56 |             continue
 57 | 
 58 | # Try to figure out the mail pattern (HunterIO + user input)
 59 | def find_mail_pattern(possible_value, possible_domain = ""):
 60 |     if possible_value != None and possible_value != "":
 61 |         print(" - HunterIO find the following mail pattern: \"%s\"" % (possible_value))
 62 |     print(" - We propose the following mail pattern for generation:")
 63 |     for mi, mp in MAIL_PATTERNS: print("  - %d/ %s" % (mi, mp))
 64 |     # Wait for user confirmation
 65 |     while True:
 66 |         pattern_result = input("\nWich pattern do you want to choose? ")
 67 |         if pattern_result.isdigit():
 68 |             if int(pattern_result) > 0 and (int(pattern_result) <= len(MAIL_PATTERNS)):
 69 |                 break
 70 | 
 71 |     if (possible_domain == None or possible_domain == ""):
 72 |         possible_domain = input("\nPlease provide a domain (@company.com): ")
 73 | 
 74 |     # Let's generate
 75 |     generate_mail_with_pattern(MAIL_PATTERNS[int(pattern_result)-1][1], possible_domain)
 76 | 
 77 | # Iterate over PEOPLE_DATA to generate email address according to pattern
 78 | # and add to "gen_email"
 79 | # return: nothing
 80 | def generate_mail_with_pattern(pattern, possible_domain):
 81 |     print(" - Generating e-mails with the following pattern: \"%s\"" % (pattern))
 82 |     for p in settings.PEOPLE_DATA:
 83 |         if (p.firstname != "") and (p.lastname != ""):
 84 |             email = build_mail(p.firstname, p.lastname, pattern)
 85 |             p.gen_email = "%s@%s" % (email, possible_domain)
 86 |     print(" - Done generating e-mails!")
 87 | 
 88 | # Build email address according to a specific (user selected) pattern
 89 | # return: email address
 90 | def build_mail(firstname, lastname, pattern):
 91 |     email = pattern
 92 |     # Correct accents
 93 |     u_firstname = unidecode(firstname).lower()
 94 |     u_lastname = unidecode(lastname).lower()
 95 |     # Replacement
 96 |     email = email.replace("{first}", u_firstname)
 97 |     email = email.replace("{last}", u_lastname)
 98 |     email = email.replace("{f}", u_lastname)
 99 |     return email
100 | 
101 | # Display info gathered to user
102 | def display_people():
103 |     display_list = []
104 |     for p in settings.PEOPLE_DATA:
105 |         display_list.append(p.prep4display())
106 |     print(tabulate(display_list, ["Full name", "RocketReach"], "grid"))
107 | 
108 | # Write output to file
109 | def write_people(output_file):
110 |     print("\n[!] Writing data to file")
111 |     HEADERS = "fullname;first name;last name;valid emails;generated email;phones;city;country;job;employer;twitter;rocket ID;"
112 |     # Write headers
113 |     write_to_file(output_file, "w", HEADERS)
114 |     for p in settings.PEOPLE_DATA:
115 |         write_to_file(output_file, "a", p.prep4write())
116 |     print("[!] Done writing!")
117 | 
118 | # Clean data before writing to file
119 | def clean_data(data):
120 |     if data != None:
121 |         if type(data) == list:
122 |             data = ",".join(data)
123 |         if type(data) == str:
124 |             data = data.replace("\n","")
125 |         return data
126 |     else:
127 |         return ""
128 | 
129 | # Exiting program with custom message
130 | def exiting(message):
131 |     print("[!] %s" % message)
132 |     print("Exiting...")
133 |     sys.exit(1)
134 | 
135 | ### Class
136 | class People:
137 |     def __init__(self):
138 |         self.fullname = ""
139 |         self.firstname = ""
140 |         self.lastname = ""
141 |         self.job = ""
142 |         self.employer = ""
143 |         self.emails = []
144 |         self.gen_email = ""
145 |         self.phones = []
146 |         self.twitter = ""
147 |         self.city = ""
148 |         self.country_code = ""
149 |         self.rocket_id = ""
150 |         self.rocket_status = ""
151 | 
152 |     # Parse info from RocketReach API
153 |     def parse_from_rocketReach(self, fullname, job, employer, city, country_code, r_id, r_status):
154 |         if fullname != None:
155 |             self.fullname = fullname
156 |             self.split_lastname()
157 |         if job != None:
158 |             self.job = job
159 |         if employer != None:
160 |             self.employer = employer
161 |         if city != None:
162 |             self.city = city
163 |         if country_code != None:
164 |             self.country_code = country_code
165 |         if r_id != None:
166 |             self.rocket_id = int(r_id)
167 |         if r_status != None:
168 |             self.rocket_status = r_status
169 | 
170 |     # Parse info from HunterIO API
171 |     def parse_from_hunterIO(self, first_name, last_name, email, phone_number, twitter):
172 |         if first_name != None:
173 |             self.firstname = first_name
174 |         if last_name != None:
175 |             self.lastname = last_name
176 |         self.fullname = "%s %s" % (self.firstname, self.lastname)
177 |         if email != None:
178 |             properly_add_to_list(self.emails, email)
179 |         if phone_number != None:
180 |             properly_add_to_list(self.phones, phone_number)
181 |         if twitter != None:
182 |             self.twitter = twitter
183 | 
184 |     # Try to determine first and last names
185 |     def split_lastname(self):
186 |         if(len(self.fullname.split(" ")) == 2): # Don't handle more than split(" ") == 2
187 |             first = self.fullname.split(" ")[0] #
188 |             second = self.fullname.split(" ")[1]
189 |             if (first.isupper()) and not (second.isupper()): # If LASTNAME and firstname
190 |                 self.firstname = second
191 |                 self.lastname = first
192 |             else:
193 |                 self.firstname = first
194 |                 self.lastname = second
195 | 
196 |     # Prep. in order to display info to user
197 |     def prep4display(self):
198 |         # Regularly "job" is too large for a proper display
199 |         content = "Job: %s\n" % (split_long_string(clean_data(self.job), MAX_CHARS))
200 |         # Iterate over info
201 |         for txt, elt in [("Employer: %s\n", self.employer), ("Country code: %s\n", self.country_code),
202 |             ("City: %s\n", self.city), ("RocketReach ID: %s\n", self.rocket_id), ("Phones: %s\n", self.phones),
203 |             ("Twitter: %s\n", self.twitter), ("Valid emails: %s\n", self.emails), ("Generated email: %s\n", self.gen_email)]:
204 |             result = clean_data(elt)
205 |             if result != "":
206 |                 content += (txt % (result))
207 | 
208 |         info_name = "%s\n\nFirst name: %s\nLast name: %s" % (clean_data(self.fullname), clean_data(self.firstname), clean_data(self.lastname))
209 |         return [info_name, content]
210 | 
211 |     # Prep. in order to write data to file
212 |     def prep4write(self):
213 |         content = ""
214 |         for elt in [self.fullname, self.firstname, self.lastname, self.emails, self.gen_email, self.phones, self.city, self.country_code,
215 |             self.job, self.employer, self.twitter, self.rocket_id]:
216 |             content += "%s;" % clean_data(elt)
217 |         return content
218 | 
219 |     # __str__
220 |     def __str__(self):
221 |         return(self.fullname)
222 | 


--------------------------------------------------------------------------------