jobs2mongo.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ETL workflow"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extract Raw Data"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Extract data from first API: JSearch\n",
    "https://rapidapi.com/letscrape-6bRBa3QguO5/api/jsearch/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def api_1_mongo(api_data, collection):\n",
    "    job_dict = {}\n",
    "    for i in range(len(api_data[\"data\"])):\n",
    "            job_dict = api_data[\"data\"][i]\n",
    "            collection.insert_one(job_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pymongo\n",
    "import requests\n",
    "\n",
    "# connect to mogoDB\n",
    "client = pymongo.MongoClient(\"mongodb://localhost:27017/\")\n",
    "db = client[\"bigdata\"]\n",
    "\n",
    "url = \"https://jsearch.p.rapidapi.com/search\"\n",
    "\n",
    "query_jobs = [\"Software Engineer\", \"Technical Manager\", \"Data Scientist\",  \"Researcher\", \"Cloud Developer\"]\n",
    "collection_list = [\"software_engineer\",\"technical_manager\", \"data_scientist\",  \"researcher\", \"cloud_developer\"]\n",
    "headers = {\n",
    "\t\"content-type\": \"application/octet-stream\",\n",
    "\t\"X-RapidAPI-Key\": \"5dcca9a446mshc45e979b7c63b61p110313jsn2355dc91241e\",\n",
    "\t\"X-RapidAPI-Host\": \"jsearch.p.rapidapi.com\"\n",
    "}\n",
    "\n",
    "for i in range(len(query_jobs)):\n",
    "    querystring = {\"query\":query_jobs[i],\"page\":\"1\",\"num_pages\":\"20\",\"date_posted\":\"all\"}\n",
    "    response = requests.get(url, headers=headers, params=querystring)\n",
    "    data_dict = response.json()\n",
    "    collection = db[collection_list[i]]\n",
    "    api_1_mongo(data_dict, collection)\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Extract data from second API: linked in \n",
    "https://rapidapi.com/jaypat87/api/linkedin-jobs-search/\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def api_2_mongo(apidata, collection):\n",
    "   for i, item in enumerate(apidata):\n",
    "      if isinstance(item, dict):\n",
    "         collection.insert_one(item)\n",
    "         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "url = \"https://linkedin-jobs-search.p.rapidapi.com/\"\n",
    "\n",
    "headers = {\n",
    " \"content-type\": \"application/json\",\n",
    " \"X-RapidAPI-Key\": \"5dcca9a446mshc45e979b7c63b61p110313jsn2355dc91241e\",\n",
    " \"X-RapidAPI-Host\": \"linkedin-jobs-search.p.rapidapi.com\"\n",
    "}\n",
    "\n",
    "\n",
    "for i in range(len(query_jobs)):\n",
    "    payload = {\n",
    "\t\t\"search_terms\":query_jobs[i],\n",
    "\t\t\"location\": \"United States\",\n",
    "\t\t\"page\": 1\n",
    "\t\t}\n",
    "    response = requests.post(url, json=payload, headers=headers)\n",
    "    data_dict = response.json()\n",
    "    collection = db[collection_list[i]]\n",
    "    api_2_mongo(data_dict, collection)\n",
    "        \n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Extract data from third API\n",
    "Indeed, Talent, Snagajob, Careerbuilder and Nexxt\n",
    "\n",
    "https://rapidapi.com/jaypat87/api/indeed11\n",
    "\n",
    "This APi is used for get pay for each job"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def api_3_mongo(apidata, collection, location):\n",
    "   try:\n",
    "      for item in apidata[\"results\"]:\n",
    "          insert_dict = {\"location\" :location}\n",
    "          insert_dict['job_title'] = item['job']['job_title']\n",
    "          insert_dict['company'] = item['job']['company']\n",
    "          insert_dict['job_details'] = item['job_details']['link']\n",
    "          insert_dict['pay'] = item['job_details']['pay']\n",
    "          collection.insert_one(insert_dict)\n",
    "   except KeyError:\n",
    "      print(apidata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "new collections:  ['software_engineer_pay', 'technical_manager_pay', 'data_scientist_pay', 'researcher_pay', 'cloud_developer_pay']\n",
      "{'message': 'You have exceeded the MONTHLY quota for Requests on your current plan, BASIC. Upgrade your plan at https://rapidapi.com/fastapply/api/job-board-search-fastapply'}\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "url = \"https://job-board-search-fastapply.p.rapidapi.com/us/snagajob/fetchjobs\"\n",
    "headers =[{\n",
    "\t\"content-type\": \"application/json\",\n",
    "\t\"X-RapidAPI-Key\": \"394d899556msh4f0740173b447c1p1e6a45jsnfd1521c2520f\",\n",
    "\t\"X-RapidAPI-Host\": \"job-board-search-fastapply.p.rapidapi.com\"\n",
    "},\n",
    " {\n",
    " \"content-type\": \"application/json\",\n",
    " \"X-RapidAPI-Key\": \"5dcca9a446mshc45e979b7c63b61p110313jsn2355dc91241e\",\n",
    " \"X-RapidAPI-Host\": \"job-board-search-fastapply.p.rapidapi.com\"\n",
    "},\n",
    "{\n",
    "    'content-type': 'application/json',\n",
    "    'X-RapidAPI-Key': 'a668dfde94msh4ef920baed52701p11288cjsnd7650a4668cf',\n",
    "    'X-RapidAPI-Host': 'job-board-search-fastapply.p.rapidapi.com'\n",
    "  },\n",
    "  {\n",
    "\t\"content-type\": \"application/json\",\n",
    "\t\"X-RapidAPI-Key\": \"84053fe846msh32e4835fd7634fcp161e65jsn2bab6bacf9cb\",\n",
    "\t\"X-RapidAPI-Host\": \"job-board-search-fastapply.p.rapidapi.com\"\n",
    "}\n",
    "] \n",
    "\n",
    "pay_collection_list = []\n",
    "\n",
    "for item in collection_list:\n",
    "    item =item.strip()+ \"_pay\"\n",
    "    pay_collection_list.append(item)\n",
    "print(\"new collections: \", pay_collection_list)\n",
    "\n",
    "locations = [\"New York\", \"California\", \"Washington\", \"Texas\",\"Illinois\", \"Remote\"]\n",
    "header_count = 0\n",
    "prev_data = None\n",
    "for i in range(len(query_jobs)):\n",
    "    for location in locations:\n",
    "        payload = {\n",
    "\t\t\"keyword\": query_jobs[i],\n",
    "\t\t\"location\": location,\n",
    "\t\t\"radius\": 15,\n",
    "\t\t\"page_number\": 1\n",
    "\t\t} \n",
    "        try:\n",
    "            response = requests.post(url, json=payload, headers=headers[header_count])\n",
    "        \n",
    "            if(response.json() == {'message': 'You have exceeded the rate limit per minute for your plan, BASIC, by the API provider'}):\n",
    "                header_count += 1\n",
    "                continue\n",
    "            if(response.json() == prev_data):\n",
    "                continue\n",
    "            \n",
    "            data_dict = response.json()\n",
    "            collection = db[pay_collection_list[i]]\n",
    "            api_3_mongo(data_dict, collection, location)\n",
    "            prev_data = response.json()\n",
    "        except IndexError:\n",
    "            print(\"end\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transform Raw Data"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Unify fields name from different APIs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pymongo.results.UpdateResult at 0x117f38d90>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pymongo\n",
    "\n",
    "# Connect to MongoDB\n",
    "client = pymongo.MongoClient('mongodb://localhost:27017')\n",
    "db = client['bigdata']\n",
    "collection = db['software_engineer']\n",
    "\n",
    "# Update the field name\n",
    "collection.update_many({}, {\"$rename\": {\"job_url\": \"job_apply_link\"}})\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Clean Wrong Data(Title doeen't match with query's title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_title_wrong_data(field, value, collection, colname):\n",
    "    query = {field : {\"$exists\":True}}\n",
    "    value_split = value.split()\n",
    "    documents = collection.find(query)\n",
    "    clean_count = 0\n",
    "    for doc in documents:\n",
    "        title = doc[field]\n",
    "        lower_title =title.lower()\n",
    "        for item in value_split:\n",
    "            if item in lower_title:\n",
    "                continue\n",
    "            else:\n",
    "                clean_count += 1\n",
    "                collection.find_one_and_delete({field : title})\n",
    "                \n",
    "    print(colname,\"collection cleaned data :\", clean_count)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "software_engineer_pay collection cleaned data : 54\n",
      "technical_manager_pay collection cleaned data : 184\n",
      "data_scientist_pay collection cleaned data : 121\n",
      "researcher_pay collection cleaned data : 146\n",
      "cloud_developer_pay collection cleaned data : 271\n"
     ]
    }
   ],
   "source": [
    "client = pymongo.MongoClient(\"mongodb://localhost:27017/\")\n",
    "db = client[\"bigdata\"]\n",
    "\n",
    "for i in range(len(query_jobs)):\n",
    "    clean_title_wrong_data(field=\"job_title\", value = query_jobs[i].lower(), collection=db[pay_collection_list[i]], colname = pay_collection_list[i])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Clean Data Without \"pay_hourly\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "def clean_pay_noexist(collection, col_name):\n",
    "    ori_doc = collection.count_documents({})\n",
    "    query = {\"pay.pay_hourly\" : {\"$exists\": False}}\n",
    "    collection.delete_many(query)\n",
    "    cur_doc = collection.count_documents({})\n",
    "    print(col_name , \"collection cleaned data: \", ori_doc - cur_doc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "software_engineer_pay collection cleaned data:  0\n",
      "technical_manager_pay collection cleaned data:  0\n",
      "data_scientist_pay collection cleaned data:  0\n",
      "researcher_pay collection cleaned data:  0\n",
      "cloud_developer_pay collection cleaned data:  0\n"
     ]
    }
   ],
   "source": [
    "client = pymongo.MongoClient(\"mongodb://localhost:27017/\")\n",
    "db = client[\"bigdata\"]\n",
    "\n",
    "for i in range(len(pay_collection_list)):\n",
    "   clean_pay_noexist(db[pay_collection_list[i]],pay_collection_list[i])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Clean Duplicate Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_duplicate(collection, col_name):\n",
    "    print(col_name, \"before clean duplicate:\" ,collection.count_documents({}))\n",
    "    if \"pay\" in col_name:\n",
    "    # Find duplicatedata\n",
    "        deleteData = collection.aggregate([\n",
    "        {\n",
    "            \"$group\": {\n",
    "            '_id': { 'field1': \"$job_details\"},\n",
    "            'count': { \"$sum\": 1 },\n",
    "            'uniqueIds': { \"$addToSet\": \"$_id\" }\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$match\": {\n",
    "            'count': { \"$gt\": 1 }\n",
    "            }\n",
    "        }\n",
    "        ])\n",
    "    else:\n",
    "        deleteData = collection.aggregate([\n",
    "        {\n",
    "            \"$group\": {\n",
    "            '_id': { 'field1': \"$job_apply_link\"},\n",
    "            'count': { \"$sum\": 1 },\n",
    "            'uniqueIds': { \"$addToSet\": \"$_id\" }\n",
    "            }\n",
    "        },\n",
    "        {\n",
    "            \"$match\": {\n",
    "            'count': { \"$gt\": 1 }\n",
    "            }\n",
    "        }\n",
    "        ])\n",
    "    first=True\n",
    "    for d in deleteData:\n",
    "        first=True\n",
    "        for did in d['uniqueIds']:\n",
    "            if not first:    # don't delete first\n",
    "                collection.delete_one({'_id':did});\n",
    "            first=False\n",
    "    print(col_name, \"after clean duplicate:\" ,collection.count_documents({}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "software_engineer_pay before clean duplicate: 66\n",
      "software_engineer_pay after clean duplicate: 66\n",
      "technical_manager_pay before clean duplicate: 1\n",
      "technical_manager_pay after clean duplicate: 1\n",
      "data_scientist_pay before clean duplicate: 39\n",
      "data_scientist_pay after clean duplicate: 39\n",
      "researcher_pay before clean duplicate: 4\n",
      "researcher_pay after clean duplicate: 4\n",
      "cloud_developer_pay before clean duplicate: 0\n",
      "cloud_developer_pay after clean duplicate: 0\n",
      "software_engineer before clean duplicate: 369\n",
      "software_engineer after clean duplicate: 232\n",
      "technical_manager before clean duplicate: 347\n",
      "technical_manager after clean duplicate: 228\n",
      "data_scientist before clean duplicate: 366\n",
      "data_scientist after clean duplicate: 249\n",
      "researcher before clean duplicate: 370\n",
      "researcher after clean duplicate: 227\n",
      "cloud_developer before clean duplicate: 369\n",
      "cloud_developer after clean duplicate: 217\n"
     ]
    }
   ],
   "source": [
    "for item in pay_collection_list:\n",
    "    collection = db[item]\n",
    "    clean_duplicate(collection, item)\n",
    "\n",
    "for item in collection_list:\n",
    "    collection = db[item]\n",
    "    clean_duplicate(collection, item)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Analyse (Plot salary of different jobs and locations)\n",
    "A simple example using our data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_salary(pay_collection, job_title) :\n",
    "    query = {\"pay.pay_hourly\" : {\"$gt\": 0}}\n",
    "    documents = pay_collection.find(query)\n",
    "    job_name = []\n",
    "    salary = []\n",
    "    for doc in documents:\n",
    "        try:\n",
    "            pay_per_year = doc['pay']['pay_yearly']\n",
    "            salary.append(pay_per_year)\n",
    "            job_name.append(job_title)\n",
    "        except KeyError:\n",
    "            continue\n",
    "    return salary, job_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[184000.0, 124000.0, 124000.0, 124000.0, 124000.0, 122000.0, 122000.0, 122000.0, 122000.0, 100000.0, 100000.0, 100000.0, 100000.0, 102000.0, 102000.0, 36000.0, 102000.0, 102000.0, 102000.0, 102000.0, 102000.0, 102000.0, 102000.0, 102000.0, 100000.0, 100000.0, 100000.0, 100000.0, 100000.0, 100000.0, 124000.0, 124000.0, 124000.0, 124000.0, 122000.0, 122000.0, 122000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 120000.0, 146000.0, 146000.0, 120000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 120000.0, 146000.0, 146000.0, 146000.0, 146000.0, 146000.0, 44000.0, 122000.0, 122000.0, 122000.0, 122000.0, 122000.0, 124000.0, 124000.0, 124000.0, 96000.0, 98000.0, 122000, 122000.0, 114000.0, 98000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 96000.0, 98000.0, 98000.0, 98000.0, 96000.0, 36000.0, 34000.0, 34000.0]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "client = pymongo.MongoClient(\"mongodb://localhost:27017/\")\n",
    "db = client[\"bigdata\"]\n",
    "salary_list = []\n",
    "job_list = []\n",
    "for item in pay_collection_list:\n",
    "    collection = db[item]\n",
    "    salary, job_name = plot_salary(collection, item[0:-4])\n",
    "    for data in salary:\n",
    "        salary_list.append(data)\n",
    "    for name in job_name:\n",
    "        job_list.append(name)\n",
    "\n",
    "\n",
    "print(salary_list)\n",
    "y = np.array(salary_list)\n",
    "x = np.array(job_list)\n",
    "plt.scatter(x, y)\n",
    "plt.title(\"jobs salary per year($)\")\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.9"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}