1_2_Analyzing_resumes_in_pdf_format.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "# Install required libraries"
      ],
      "metadata": {
        "id": "P8OrGGJ139LN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install pdfplumber scikit-learn  # Install pdfplumber for PDF text extraction and scikit-learn for machine learning\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m2lDobT04Nhh",
        "outputId": "7d5421da-66d5-45b2-d07f-4193f5e4eccf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: pdfplumber in /usr/local/lib/python3.10/dist-packages (0.11.4)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (1.3.2)\n",
            "Requirement already satisfied: pdfminer.six==20231228 in /usr/local/lib/python3.10/dist-packages (from pdfplumber) (20231228)\n",
            "Requirement already satisfied: Pillow>=9.1 in /usr/local/lib/python3.10/dist-packages (from pdfplumber) (9.4.0)\n",
            "Requirement already satisfied: pypdfium2>=4.18.0 in /usr/local/lib/python3.10/dist-packages (from pdfplumber) (4.30.0)\n",
            "Requirement already satisfied: charset-normalizer>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from pdfminer.six==20231228->pdfplumber) (3.3.2)\n",
            "Requirement already satisfied: cryptography>=36.0.0 in /usr/local/lib/python3.10/dist-packages (from pdfminer.six==20231228->pdfplumber) (42.0.8)\n",
            "Requirement already satisfied: numpy<2.0,>=1.17.3 in /usr/local/lib/python3.10/dist-packages (from scikit-learn) (1.26.4)\n",
            "Requirement already satisfied: scipy>=1.5.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn) (1.13.1)\n",
            "Requirement already satisfied: joblib>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from scikit-learn) (1.4.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn) (3.5.0)\n",
            "Requirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.10/dist-packages (from cryptography>=36.0.0->pdfminer.six==20231228->pdfplumber) (1.17.0)\n",
            "Requirement already satisfied: pycparser in /usr/local/lib/python3.10/dist-packages (from cffi>=1.12->cryptography>=36.0.0->pdfminer.six==20231228->pdfplumber) (2.22)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "kx_0EtFt4NkM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "7QMdf4lS4Nmd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Import necessary libraries"
      ],
      "metadata": {
        "id": "xqzuTnKy4NrA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pdfplumber  # Library for extracting text from PDF files"
      ],
      "metadata": {
        "id": "ey-hT9Rm4Nvn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import io  # Library for handling in-memory byte streams"
      ],
      "metadata": {
        "id": "Iq1Zp43V4Nxt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np  # Library for numerical operations"
      ],
      "metadata": {
        "id": "d9V-Rvza4N0C"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd  # Library for data manipulation and analysis"
      ],
      "metadata": {
        "id": "gQFejsny4N4b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.feature_extraction.text import TfidfVectorizer  # Tool for converting text data to TF-IDF features\n"
      ],
      "metadata": {
        "id": "PmOxoYNJ4N6p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics.pairwise import cosine_similarity  # Tool for computing similarity between text data\n"
      ],
      "metadata": {
        "id": "b9JcE7dZ4N8p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import files  # Google Colab utility for file upload and download"
      ],
      "metadata": {
        "id": "T6QhnERN4qlx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from IPython.display import display, HTML  # Tools for displaying HTML content in Colab"
      ],
      "metadata": {
        "id": "CY8D-VPX4qo5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os  # Library for interacting with the operating system"
      ],
      "metadata": {
        "id": "STl5QBHW4qre"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import shutil  # Library for high-level file operations, like creating zip files"
      ],
      "metadata": {
        "id": "mQTxNMrf4quK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "PNntCDwB4314"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "qOq0uzgr4343"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Function to upload PDF files"
      ],
      "metadata": {
        "id": "w52F0ena437l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def upload_files():\n",
        "    uploaded = files.upload()  # Upload files using Google Colab's file upload widget\n",
        "    return uploaded  # Return the dictionary of uploaded files"
      ],
      "metadata": {
        "id": "xp_wXR1c43-A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Co8RW-QL49oZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "27BA-0I349ry"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Function to extract text from a PDF file"
      ],
      "metadata": {
        "id": "YyTmENLB49wI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def extract_text_from_pdf(pdf_file):\n",
        "    try:\n",
        "        with pdfplumber.open(io.BytesIO(pdf_file)) as pdf:  # Open the PDF file from an in-memory byte stream\n",
        "            text = \"\"\n",
        "            for page in pdf.pages:  # Iterate through each page in the PDF\n",
        "                text += page.extract_text() or \"\"  # Extract text from the page, or use empty string if no text is found\n",
        "        return text  # Return the concatenated text from all pages\n",
        "    except Exception as e:\n",
        "        print(f\"An error occurred while extracting text: {e}\")  # Print error message if text extraction fails\n",
        "        return \"\"  # Return an empty string in case of error"
      ],
      "metadata": {
        "id": "VqrDGiLY49zF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "--umY5hw5D54"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "TAQnKmTh5D9A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Function to analyze resumes based on job description"
      ],
      "metadata": {
        "id": "L2GonMZe5D_9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def analyze_resumes(job_description, pdf_files, pasted_resumes):\n",
        "    # Extract text from uploaded PDF files\n",
        "    resumes_from_files = [extract_text_from_pdf(pdf_files[file]) for file in pdf_files]  # Extract text from each uploaded PDF\n",
        "\n",
        "    # Combine resumes from files and pasted resumes\n",
        "    resumes = resumes_from_files + pasted_resumes  # Combine both sources of resumes\n",
        "\n",
        "    # Create a TF-IDF Vectorizer and compute the TF-IDF matrix\n",
        "    vectorizer = TfidfVectorizer()  # Initialize TF-IDF vectorizer\n",
        "    tfidf_matrix = vectorizer.fit_transform([job_description] + resumes)  # Compute TF-IDF features for job description and resumes\n",
        "\n",
        "    # Compute cosine similarity between job description and resumes\n",
        "    similarity_scores = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:]).flatten()  # Compute similarity scores\n",
        "\n",
        "    # Create a list of resumes and their similarity scores\n",
        "    results = list(zip(list(pdf_files.keys()) + ['Pasted Resume ' + str(i + 1) for i in range(len(pasted_resumes))], similarity_scores))  # Pair resume names with their similarity scores\n",
        "    results.sort(key=lambda x: x[1], reverse=True)  # Sort resumes by similarity score in descending order\n",
        "\n",
        "    return results  # Return the sorted list of results"
      ],
      "metadata": {
        "id": "BoZdioKy5EC4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "fBwWebst5EGT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "8_UHFsxk492V"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Function to save the analysis results and resumes"
      ],
      "metadata": {
        "id": "CT1YhU_V495v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def save_results_and_resumes(results, pdf_files, pasted_resumes):\n",
        "    # Create a DataFrame for results\n",
        "    results_df = pd.DataFrame(results, columns=['Resume', 'Score'])  # Create a DataFrame from the results\n",
        "    results_df = results_df.sort_values(by='Score', ascending=False).reset_index(drop=True)  # Sort DataFrame by score in descending order\n",
        "\n",
        "    # Save the results DataFrame to a CSV file\n",
        "    results_csv_path = \"/content/resume_analysis_results.csv\"  # Define file path for results CSV\n",
        "    results_df.to_csv(results_csv_path, index=False)  # Save DataFrame to CSV\n",
        "\n",
        "    # Create a directory to save resumes\n",
        "    resumes_dir = \"/content/resumes\"  # Define directory path for resumes\n",
        "    os.makedirs(resumes_dir, exist_ok=True)  # Create directory if it does not already exist\n",
        "\n",
        "    # Save PDF resumes in the order of their ranking\n",
        "    pdf_files_sorted = [file for file, _ in results]  # Get list of PDF files sorted by ranking\n",
        "    for file_name in pdf_files_sorted:\n",
        "        if file_name in pdf_files:\n",
        "            file_path = os.path.join(resumes_dir, file_name)  # Define file path for each resume\n",
        "            with open(file_path, \"wb\") as f:  # Open file in binary write mode\n",
        "                f.write(pdf_files[file_name])  # Write the PDF content to the file\n",
        "\n",
        "    # Save pasted resumes in the order of their ranking\n",
        "    pasted_resumes_sorted = [resume for _, resume in sorted(zip(results, pasted_resumes), key=lambda x: x[0][1], reverse=True)]  # Sort pasted resumes by ranking\n",
        "    pasted_resumes_path = os.path.join(resumes_dir, \"pasted_resumes.txt\")  # Define path for text file with pasted resumes\n",
        "    with open(pasted_resumes_path, \"w\") as f:  # Open file in write mode\n",
        "        for i, resume in enumerate(pasted_resumes_sorted):  # Iterate through sorted pasted resumes\n",
        "            f.write(f\"--- Pasted Resume {i + 1} ---\\n\")  # Write header for each resume\n",
        "            f.write(resume)  # Write resume content\n",
        "            f.write(\"\\n\\n\")  # Add new line after each resume\n",
        "\n",
        "    return results_csv_path, resumes_dir  # Return paths for results CSV and resumes directory"
      ],
      "metadata": {
        "id": "5X5ZEMoZ44Al"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "nZq7pt-s44Dd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "nGSxCRlO4qwG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Upload files and paste resume content"
      ],
      "metadata": {
        "id": "nuTiTeCz4N_R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Upload your PDF resumes:\")  # Prompt user to upload PDF files\n",
        "uploaded_files = upload_files()  # Call function to upload files"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 717
        },
        "id": "ZsewbA6V4OBD",
        "outputId": "61248380-7d15-4b79-b1d0-35b933c168a7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Upload your PDF resumes:\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-450852c2-0b5d-4df0-bb7a-616b47b6e75b\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-450852c2-0b5d-4df0-bb7a-616b47b6e75b\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script>// Copyright 2017 Google LLC\n",
              "//\n",
              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
              "// you may not use this file except in compliance with the License.\n",
              "// You may obtain a copy of the License at\n",
              "//\n",
              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
              "//\n",
              "// Unless required by applicable law or agreed to in writing, software\n",
              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
              "// See the License for the specific language governing permissions and\n",
              "// limitations under the License.\n",
              "\n",
              "/**\n",
              " * @fileoverview Helpers for google.colab Python module.\n",
              " */\n",
              "(function(scope) {\n",
              "function span(text, styleAttributes = {}) {\n",
              "  const element = document.createElement('span');\n",
              "  element.textContent = text;\n",
              "  for (const key of Object.keys(styleAttributes)) {\n",
              "    element.style[key] = styleAttributes[key];\n",
              "  }\n",
              "  return element;\n",
              "}\n",
              "\n",
              "// Max number of bytes which will be uploaded at a time.\n",
              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
              "\n",
              "function _uploadFiles(inputId, outputId) {\n",
              "  const steps = uploadFilesStep(inputId, outputId);\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  // Cache steps on the outputElement to make it available for the next call\n",
              "  // to uploadFilesContinue from Python.\n",
              "  outputElement.steps = steps;\n",
              "\n",
              "  return _uploadFilesContinue(outputId);\n",
              "}\n",
              "\n",
              "// This is roughly an async generator (not supported in the browser yet),\n",
              "// where there are multiple asynchronous steps and the Python side is going\n",
              "// to poll for completion of each step.\n",
              "// This uses a Promise to block the python side on completion of each step,\n",
              "// then passes the result of the previous step as the input to the next step.\n",
              "function _uploadFilesContinue(outputId) {\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  const steps = outputElement.steps;\n",
              "\n",
              "  const next = steps.next(outputElement.lastPromiseValue);\n",
              "  return Promise.resolve(next.value.promise).then((value) => {\n",
              "    // Cache the last promise value to make it available to the next\n",
              "    // step of the generator.\n",
              "    outputElement.lastPromiseValue = value;\n",
              "    return next.value.response;\n",
              "  });\n",
              "}\n",
              "\n",
              "/**\n",
              " * Generator function which is called between each async step of the upload\n",
              " * process.\n",
              " * @param {string} inputId Element ID of the input file picker element.\n",
              " * @param {string} outputId Element ID of the output display.\n",
              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
              " */\n",
              "function* uploadFilesStep(inputId, outputId) {\n",
              "  const inputElement = document.getElementById(inputId);\n",
              "  inputElement.disabled = false;\n",
              "\n",
              "  const outputElement = document.getElementById(outputId);\n",
              "  outputElement.innerHTML = '';\n",
              "\n",
              "  const pickedPromise = new Promise((resolve) => {\n",
              "    inputElement.addEventListener('change', (e) => {\n",
              "      resolve(e.target.files);\n",
              "    });\n",
              "  });\n",
              "\n",
              "  const cancel = document.createElement('button');\n",
              "  inputElement.parentElement.appendChild(cancel);\n",
              "  cancel.textContent = 'Cancel upload';\n",
              "  const cancelPromise = new Promise((resolve) => {\n",
              "    cancel.onclick = () => {\n",
              "      resolve(null);\n",
              "    };\n",
              "  });\n",
              "\n",
              "  // Wait for the user to pick the files.\n",
              "  const files = yield {\n",
              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
              "    response: {\n",
              "      action: 'starting',\n",
              "    }\n",
              "  };\n",
              "\n",
              "  cancel.remove();\n",
              "\n",
              "  // Disable the input element since further picks are not allowed.\n",
              "  inputElement.disabled = true;\n",
              "\n",
              "  if (!files) {\n",
              "    return {\n",
              "      response: {\n",
              "        action: 'complete',\n",
              "      }\n",
              "    };\n",
              "  }\n",
              "\n",
              "  for (const file of files) {\n",
              "    const li = document.createElement('li');\n",
              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
              "    li.append(span(\n",
              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
              "        `last modified: ${\n",
              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
              "                                    'n/a'} - `));\n",
              "    const percent = span('0% done');\n",
              "    li.appendChild(percent);\n",
              "\n",
              "    outputElement.appendChild(li);\n",
              "\n",
              "    const fileDataPromise = new Promise((resolve) => {\n",
              "      const reader = new FileReader();\n",
              "      reader.onload = (e) => {\n",
              "        resolve(e.target.result);\n",
              "      };\n",
              "      reader.readAsArrayBuffer(file);\n",
              "    });\n",
              "    // Wait for the data to be ready.\n",
              "    let fileData = yield {\n",
              "      promise: fileDataPromise,\n",
              "      response: {\n",
              "        action: 'continue',\n",
              "      }\n",
              "    };\n",
              "\n",
              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
              "    let position = 0;\n",
              "    do {\n",
              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
              "      const chunk = new Uint8Array(fileData, position, length);\n",
              "      position += length;\n",
              "\n",
              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
              "      yield {\n",
              "        response: {\n",
              "          action: 'append',\n",
              "          file: file.name,\n",
              "          data: base64,\n",
              "        },\n",
              "      };\n",
              "\n",
              "      let percentDone = fileData.byteLength === 0 ?\n",
              "          100 :\n",
              "          Math.round((position / fileData.byteLength) * 100);\n",
              "      percent.textContent = `${percentDone}% done`;\n",
              "\n",
              "    } while (position < fileData.byteLength);\n",
              "  }\n",
              "\n",
              "  // All done.\n",
              "  yield {\n",
              "    response: {\n",
              "      action: 'complete',\n",
              "    }\n",
              "  };\n",
              "}\n",
              "\n",
              "scope.google = scope.google || {};\n",
              "scope.google.colab = scope.google.colab || {};\n",
              "scope.google.colab._files = {\n",
              "  _uploadFiles,\n",
              "  _uploadFilesContinue,\n",
              "};\n",
              "})(self);\n",
              "</script> "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving amazon-data-science-resume-example.pdf to amazon-data-science-resume-example (3).pdf\n",
            "Saving associate-data-scientist-resume-example.pdf to associate-data-scientist-resume-example (3).pdf\n",
            "Saving data-science-manager-resume-example.pdf to data-science-manager-resume-example (3).pdf\n",
            "Saving data-science-student-resume-example.pdf to data-science-student-resume-example (3).pdf\n",
            "Saving data-scientist-analytics-resume-example.pdf to data-scientist-analytics-resume-example (3).pdf\n",
            "Saving data-scientist-intern-resume-example.pdf to data-scientist-intern-resume-example (3).pdf\n",
            "Saving data-scientist-machine-learning-resume-example.pdf to data-scientist-machine-learning-resume-example (3).pdf\n",
            "Saving data-scientist-resume-example.pdf to data-scientist-resume-example (3).pdf\n",
            "Saving data-visualization-resume-example.pdf to data-visualization-resume-example (3).pdf\n",
            "Saving educational-data-scientist-resume-example.pdf to educational-data-scientist-resume-example (3).pdf\n",
            "Saving entry-level-data-scientist-resume-example.pdf to entry-level-data-scientist-resume-example (3).pdf\n",
            "Saving experienced-data-scientist-resume-example.pdf to experienced-data-scientist-resume-example (3).pdf\n",
            "Saving google-data-scientist-resume-example.pdf to google-data-scientist-resume-example (3).pdf\n",
            "Saving healthcare-data-scientist-resume-example.pdf to healthcare-data-scientist-resume-example (3).pdf\n",
            "Saving metadata-scientist-resume-example.pdf to metadata-scientist-resume-example (3).pdf\n",
            "Saving nlp-data-scientist-resume-example.pdf to nlp-data-scientist-resume-example (3).pdf\n",
            "Saving python-data-scientist-resume-example.pdf to python-data-scientist-resume-example (3).pdf\n",
            "Saving senior-data-scientist-resume-example.pdf to senior-data-scientist-resume-example (3).pdf\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "jXKlRaD15epg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pdf_files = uploaded_files  # Store uploaded files"
      ],
      "metadata": {
        "id": "O2u4rKRo5ez0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "F8XIhUZU3gvT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "TpX0_Jh_3gyA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Paste resume content for analysis"
      ],
      "metadata": {
        "id": "1h1ezThN3g05"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Paste resume content below (one per line):\")  # Prompt user to paste resume content\n",
        "pasted_resumes = [\n",
        "    \"Paste resume content here, separated by line breaks.\"  # Example placeholder for pasted resumes\n",
        "]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aFQRL5Ny3g3X",
        "outputId": "d9612f19-ccf8-4e53-bcdb-8f747c12237e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Paste resume content below (one per line):\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "L9yzdo8W5rOX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "SsHQ0jiT5r6w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Define job description for analysis"
      ],
      "metadata": {
        "id": "_wtI4ZKg5sBJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "job_description = \"Software engineer with experience in Python, machine learning, and data analysis.\"  # Example job description\n"
      ],
      "metadata": {
        "id": "OxmQKn_x5sFB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Q1ZnYgkT506J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "ZXnyJYrS51NL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Analyze resumes and save results"
      ],
      "metadata": {
        "id": "EjurIimk51QJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "results = analyze_resumes(job_description, pdf_files, pasted_resumes)  # Call function to analyze resumes\n"
      ],
      "metadata": {
        "id": "A98X3N-S54SJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "results_csv_path, resumes_dir = save_results_and_resumes(results, pdf_files, pasted_resumes)  # Save analysis results and resumes\n"
      ],
      "metadata": {
        "id": "Y_VLjwjv54VZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "shQG6sH_54YS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "1ffXti1554bB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Display results"
      ],
      "metadata": {
        "id": "mQW9u5q154d8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "results_df = pd.read_csv(results_csv_path)  # Read the results CSV into a DataFrame"
      ],
      "metadata": {
        "id": "Y281IpVs5_XY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "display(HTML(results_df.to_html(index=False)))  # Display the results in an HTML table format"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 645
        },
        "id": "Yipnm8Q05_a3",
        "outputId": "6606e455-4a84-41b3-ee21-75a8e8e20497"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th>Resume</th>\n",
              "      <th>Score</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <td>data-scientist-machine-learning-resume-example (3).pdf</td>\n",
              "      <td>0.268810</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>amazon-data-science-resume-example (3).pdf</td>\n",
              "      <td>0.223810</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>associate-data-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.211646</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>educational-data-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.173355</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>data-scientist-analytics-resume-example (3).pdf</td>\n",
              "      <td>0.170449</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>senior-data-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.170337</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>experienced-data-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.167907</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>data-science-manager-resume-example (3).pdf</td>\n",
              "      <td>0.165832</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>python-data-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.162386</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>metadata-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.160388</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>entry-level-data-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.159861</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>data-science-student-resume-example (3).pdf</td>\n",
              "      <td>0.157432</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>healthcare-data-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.129597</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>data-visualization-resume-example (3).pdf</td>\n",
              "      <td>0.127028</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>google-data-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.123270</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>data-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.104838</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>data-scientist-intern-resume-example (3).pdf</td>\n",
              "      <td>0.062303</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>nlp-data-scientist-resume-example (3).pdf</td>\n",
              "      <td>0.058053</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <td>Pasted Resume 1</td>\n",
              "      <td>0.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Mdd172Xj5_d6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "RJ8N00Va5_hO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Provide download links for results and resumes"
      ],
      "metadata": {
        "id": "ij-ijLHi6JJY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(f\"Download the results CSV file from: {results_csv_path}\")  # Print path to the results CSV\n",
        "print(f\"Download the resumes directory from: {resumes_dir}\")  # Print path to the resumes directory"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j6YQJxns5_kY",
        "outputId": "abf348ae-121c-4c57-f109-1c4697409c32"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Download the results CSV file from: /content/resume_analysis_results.csv\n",
            "Download the resumes directory from: /content/resumes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "2NRRkDHU6MzK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "OxOLijoX6M2l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Allow downloading the results CSV file"
      ],
      "metadata": {
        "id": "VGUQunt76M6a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "files.download(results_csv_path)  # Provide download link for the results CSV"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "C30BgOnn6Ubz",
        "outputId": "cce44217-7fae-49ad-bd90-69c71ee126b8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_5f8b1f1c-3470-471a-a386-325215478265\", \"resume_analysis_results.csv\", 1216)"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "5l9Bcm6U6Ues"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "NxL2UiC56UiL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a zip archive of the resumes directory and provide download link"
      ],
      "metadata": {
        "id": "QaAMiT-y6ZzL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "shutil.make_archive('/content/resumes_archive', 'zip', resumes_dir)  # Create a zip file of the resumes directory\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "RLPfURcF6a9M",
        "outputId": "1f446a32-d4b0-4e9d-fca0-82d13f0b91eb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'/content/resumes_archive.zip'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "yA-NVPAz6hyh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "files.download('/content/resumes_archive.zip')  # Provide download link for the zip archive"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "bVf1bHB26bDT",
        "outputId": "0fbd5514-e81d-42fd-d329-73751fb6db7d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_2f948cfc-09de-4666-805a-8b7c15cb6c68\", \"resumes_archive.zip\", 2731939)"
            ]
          },
          "metadata": {}
        }
      ]
    }
  ]
}