Resume Renamer 260120

1. The Problem

Students and applicants rarely follow file naming conventions. You likely have a folder that looks like this:

Resume.pdf

CV_Final_v2.docx

MyResume(1).pdf

john_doe.pdf

This makes sorting by date or qualification impossible without opening every single file.

The Goal: Automatically rename these files based on their content to a standard format:

YYMMDD Name Degree/Background.pdf

Example: 250101 Juan Dela Cruz BS Information Technology.pdf

2. Requirements Checklist

Please ensure you have the following ready before starting.

[ ] Ubuntu 24.04 System.

[ ] Python 3.12+ (Pre-installed on Ubuntu 24.04).

[ ] Ollama installed locally (The AI engine).

[ ] A Small Language Model pulled (e.g., granite3.3:2b or llama3.2).

• Note: Small models are fast but can make mistakes. The script has logic to catch these, but a human review is always recommended.

[ ] Python Libraries: pdfplumber (for PDFs), python-docx (for Word), requests (to talk to Ollama).

[ ] No Images: The files must have embedded text. This script excludes OCR (Optical Character Recognition) to keep it fast and lightweight. Pure image scans will be skipped.

3. How the Script Works (The Logic)

This script acts as a "Project Manager" that hires two distinct specialists to process each file. It does not blindly ask the AI for everything, as small AIs make mistakes with math and dates.

File Discovery:

1. • The script looks for .pdf and .docx files in the folder where the script is located.

Text Extraction:

1. • It pulls raw text. If the text is less than 50 characters (likely an image scan), it skips the file.

The Date Specialist (Python Regex):

1. • Logic: It scans the text for explicit years (e.g., "2023", "2024").
   • Rule: It ignores the word "Present". Why? If a resume from 2022 says "2022 - Present", treating "Present" as "Today" (2026) would incorrectly date the old resume. We stick to the highest printed number.
   • Output: Sets the date to Jan 1st of the highest year found (e.g., 240101).

The Content Specialist (Ollama AI):

1. • Logic: It sends the text to the local AI with strict instructions.
   • Rule 1 (Priority): It looks for a Degree (e.g., "BS IT") first. It is forbidden from using "Intern" or "Student" if a degree is found.
   • Rule 2 (Fallback): If the AI fails to find a name, the script grabs the first line of the document as a fallback.

Sanitization & Renaming:

1. • It fixes "Spaced Names" (e.g., J O H N -> John).
   • It ensures the filename isn't too long.
   • It renames the file only if the name doesn't already exist.

4. Installation Guide (Ubuntu 24.04)

Open your terminal (Ctrl+Alt+T) and follow these steps exactly.

Step A: System Update

Ensure your system tools are fresh to avoid installation conflicts.

sudo apt update && sudo apt upgrade -y

Step B: Install Ollama & The Model

Install the Ollama Engine:

1. curl -fsSL https://ollama.com/install.sh | sh
   

Download the Brain (The Model):

1. We use granite3.3:2b because it is very fast.

   ollama pull granite3.3:2b
   

Step C: Setup Python Environment

Ubuntu 24.04 requires Virtual Environments (venv) for Python scripts.

Create a Project Folder:

1. mkdir ~/resume_renamer
   cd ~/resume_renamer
   

Create the Virtual Environment:

1. python3 -m venv venv
   

Activate the Environment:

1. source venv/bin/activate
   

   (You should see (venv) at the start of your command line now).

Install Required Libraries:

1. pip install requests pdfplumber python-docx
   

Step D: Create the Script

Create the python file:

1. nano rename_resumes.py
   

Paste the Python code provided in the appendix below.

Save and exit: Press Ctrl+O, Enter, then Ctrl+X.

5. Running the Renamer

This script is portable. It works on the files sitting next to it.

Copy the Script: Move the rename_resumes.py file into your folder full of PDFs (e.g., ~/Documents/Student_CVs).

Open Terminal in that folder:

1. cd ~/Documents/Student_CVs
   

Activate your Python Environment (Point to where you created it):

1. source ./venv/bin/activate
   

Run the script:

1. python3 rename_resumes.py
   

6. Common Errors & Troubleshooting

Error / Behavior	Why it happens	The Fix (Included in Script)
"Intern" instead of "Degree"	The Resume had "INTERN" in big bold letters.	The script's prompt explicitly forbids "Intern" if a Degree is found.
Wrong Date (e.g., 260101)	The resume said "2021-Present" and the script assumed "Present" = 2026.	We disabled "Present" logic. It now only trusts explicit numbers (e.g., 2021).
Spaced Names (J O H N)	PDF formatting added spaces between letters.	A Regex function detects single letters + spaces and collapses them.
Script Freezes	Ollama is overwhelmed.	We added a 60-second timeout and a 0.5s pause between files.
Skipped Files	The PDF is a scanned image (no text).	This is intended. You need an OCR tool for these (not included here).

Appendix: The Python Script

Rename Resumes Script

Copy the code below into rename_resumes.py.

# --- IMPROVED FUNCTION: SMART PDF READER (Skips Forms & Signature Pages) ---
def get_smart_pdf_text(filepath):
    """
    Reads PDF pages but SKIPS pages that look like 'Application Forms'.
    Returns the text of the first 2 'valid' resume pages found.
    """
    valid_text = ""
    pages_read = 0
    
    # Phrases that indicate a page is a FORM, not a Resume
    skip_phrases = [
        "APPLICATION FOR EMPLOYMENT", 
        "OFFICIAL USE ONLY", 
        "DO NOT WRITE BELOW THIS LINE",
        "PERSONAL DATA SHEET",
        "APPLICANT'S SIGNATURE",   # Found on Page 2 of your file
        "FAMILY BACKGROUND"        # Found on Page 2 of your file
    ]

    try:
        with pdfplumber.open(filepath) as pdf:
            for page in pdf.pages:
                text = page.extract_text() or ""
                
                # CHECK: Is this page just a form?
                # We check if ANY of the skip phrases appear in the text
                is_form = any(phrase in text.upper() for phrase in skip_phrases)
                
                if is_form:
                    print(f"    [INFO] Skipped a 'Form' page (found key phrase)...")
                    continue  # Skip this page, check the next one
                
                # If not a form, it's likely the resume. Keep it.
                valid_text += text + "\n"
                pages_read += 1
                
                # Stop after finding 2 valid pages of resume content
                if pages_read >= 2:
                    break
                    
    except Exception as e:
        print(f"    [ERROR] PDF Read Error: {e}")
        return ""
        
    return valid_text
# --------------------------------------

Ocr Converter Script

Copy the code below into ocr_converter.py. Of course the Renamer doesnt work with Image PDFs, so you have to convert this. Also this is only as good as the VISION model used.

python3 ocr_converter.py

import os
import subprocess
import pdfplumber

# Configuration
FOLDER_PATH = "."  # Current folder
MIN_TEXT_LENGTH = 50  # If text is less than this, we assume it's an image

def has_embedded_text(file_path):
    """Checks if a PDF already has text."""
    try:
        with pdfplumber.open(file_path) as pdf:
            full_text = ""
            for page in pdf.pages:
                text = page.extract_text()
                if text:
                    full_text += text
            
            # If we found enough text, return True
            if len(full_text.strip()) > MIN_TEXT_LENGTH:
                return True
    except Exception as e:
        print(f"Error reading {file_path}: {e}")
        return False
    return False

def ocr_file(file_path):
    """Runs OCRmyPDF on the file."""
    output_path = file_path.replace(".pdf", "_OCR.pdf")
    
    # Don't re-OCR if the output already exists
    if os.path.exists(output_path):
        print(f"Skipping {file_path} (OCR version already exists)")
        return

    print(f"🖼️  Image Detected: Converting {file_path}...")
    
    try:
        # Run the OCR command
        # --force-ocr: Process even if it thinks there is some text (often garbage in scans)
        # --deskew: Straighten crooked scans
        command = [
            "ocrmypdf", 
            "--force-ocr", 
            "--deskew", 
            file_path, 
            output_path
        ]
        
        result = subprocess.run(command, capture_output=True, text=True)
        
        if result.returncode == 0:
            print(f"✅ Success: Created {output_path}")
        else:
            print(f"❌ Failed to OCR {file_path}")
            print(result.stderr)
            
    except FileNotFoundError:
        print("❌ Error: 'ocrmypdf' is not installed. Run 'sudo apt install ocrmypdf' first.")

def main():
    print("🔍 Scanning for image-based PDFs...")
    files = [f for f in os.listdir(FOLDER_PATH) if f.lower().endswith(".pdf") and "_OCR" not in f]
    
    count = 0
    for filename in files:
        file_path = os.path.join(FOLDER_PATH, filename)
        
        if not has_embedded_text(file_path):
            ocr_file(file_path)
            count += 1
            
    if count == 0:
        print("🎉 No image-only PDFs found. All files differ have text!")
    else:
        print(f"\n✨ Processed {count} files.")

if __name__ == "__main__":
    main()

PDF 2 VCF Script

Copy the code below into pdf2vcf.py. This creates a bulk VCF file so you can load this into your contacts.

python3 pdf2vcf.py

import os
import requests
import json
import pdfplumber
import re
from datetime import datetime
import time

# --- CONFIGURATION ---
FOLDER_PATH = os.path.dirname(os.path.abspath(__file__))
OLLAMA_MODEL = "granite3.3:2b" 
# ---------------------

def get_timestamp():
    """Returns current YYMMDD-HHMMSS"""
    return datetime.now().strftime('%y%m%d-%H%M%S')

def get_short_date():
    """Returns current YYMMDD"""
    return datetime.now().strftime('%y%m%d')

# --- SMART PDF READER ---
def get_smart_pdf_text(filepath):
    """
    Reads PDF pages but SKIPS pages that look like 'Application Forms'.
    Returns the text of the first 2 'valid' resume pages found.
    """
    valid_text = ""
    pages_read = 0
    skip_phrases = [
        "APPLICATION FOR EMPLOYMENT", "OFFICIAL USE ONLY", 
        "DO NOT WRITE BELOW THIS LINE", "PERSONAL DATA SHEET",
        "APPLICANT'S SIGNATURE", "FAMILY BACKGROUND"
    ]

    try:
        with pdfplumber.open(filepath) as pdf:
            for page in pdf.pages:
                text = page.extract_text() or ""
                # CHECK: Is this page just a form?
                if any(phrase in text.upper() for phrase in skip_phrases):
                    continue 
                
                valid_text += text + "\n"
                pages_read += 1
                if pages_read >= 2: break     
    except Exception as e:
        print(f"    [ERROR] PDF Read Error: {e}")
        return ""
    return valid_text

def clean_text_for_llm(text):
    clean = " ".join(text.split())
    return clean[:6000]

def parse_name_from_filename(filename):
    """
    Fallback: Tries to guess the name from a filename like '260101 Kim Ong Diploma.pdf'
    """
    # Remove extension
    base = os.path.splitext(filename)[0]
    
    # Regex: Look for 6 digits at start, then text
    match = re.search(r'^\d{6}\s+(.*?)\s+(?:Bachelor|Diploma|Certificate|General|Master|PhD|Associate|Engineer|Architect)', base, re.IGNORECASE)
    if match:
        return match.group(1).strip()
    
    # Weaker Regex: Just take the first 3 words after the date
    match_weak = re.search(r'^\d{6}\s+([A-Za-z-]+\s+[A-Za-z-]+\s?[A-Za-z-]*)', base)
    if match_weak:
        return match_weak.group(1).strip()

    return None

def ask_ollama_extraction(text, filename):
    """
    Asks LLM to extract specific fields, using the FILENAME as a hint.
    """
    system_instruction = (
        "You are a Data Extraction Expert. Extract details from the resume.\n"
        f"CONTEXT: The file is named '{filename}'. This filename likely contains the correct spelling of the Name and Degree.\n"
        "\nRULES:\n"
        "1. **Double Check the Name:** If the resume text has OCR errors (e.g., 'K1m 0ng'), use the spelling from the Filename ('Kim Ong').\n"
        "2. **Extract:** Full Name, Educational Degree (Short), Email, Phone, and Summary.\n"
        "3. **Summary:** Write a concise 3-sentence summary of their key skills.\n"
        "\nRETURN JSON ONLY:\n"
        "{\n"
        '  "name": "John Doe",\n'
        '  "degree": "BS IT",\n'
        '  "email": "john@email.com",\n'
        '  "phone": "09123456789",\n'
        '  "summary": "Experienced in..."\n'
        "}"
    )

    prompt = f"Resume Text:\n{text}\n\n{system_instruction}"

    url = "http://localhost:11434/api/generate"
    data = {
        "model": OLLAMA_MODEL,
        "prompt": prompt,
        "stream": False,
        "format": "json", 
        "options": {"temperature": 0.1, "num_ctx": 4096}
    }

    try:
        response = requests.post(url, json=data, timeout=60)
        response.raise_for_status()
        result_json = response.json()['response']
        return json.loads(result_json)
    except Exception as e:
        print(f"    [Warning] AI Extraction failed: {e}")
        return None

def create_vcard_string(data, creation_date):
    """
    Formats the data into VCF 3.0 format.
    Format: Name Degree YYMMDD (All in First Name field for easy searching)
    """
    name = data.get("name", "Unknown")
    degree = data.get("degree", "")
    email = data.get("email", "")
    phone = data.get("phone", "")
    summary = data.get("summary", "")

    # Sanitize inputs
    if not name or name == "Unknown":
        name = "Unknown Candidate"
    
    complex_name = f"{name} {degree} {creation_date}".strip()
    
    vcf = [
        "BEGIN:VCARD",
        "VERSION:3.0",
        f"N:;{complex_name};;;", 
        f"FN:{complex_name}",
        f"TEL;TYPE=CELL:{phone}",
        f"EMAIL;TYPE=WORK:{email}",
        f"NOTE:{summary} (Extracted via AI)",
        f"REV:{datetime.now().isoformat()}",
        "END:VCARD"
    ]
    return "\n".join(vcf) + "\n"

def process_to_vcf():
    output_filename = f"{get_timestamp()}_Bulk_Import.vcf"
    output_path = os.path.join(FOLDER_PATH, output_filename)
    creation_date = get_short_date() 

    print(f"--- Smart Resume to VCF Exporter ---")
    print(f"Target Output: {output_filename}")
    
    count = 0
    
    with open(output_path, "w", encoding="utf-8") as vcf_file:
        
        for filename in os.listdir(FOLDER_PATH):
            if not filename.lower().endswith(".pdf"):
                continue

            filepath = os.path.join(FOLDER_PATH, filename)
            print(f"Processing: {filename}...")

            # 1. Get Text
            text = get_smart_pdf_text(filepath)
            if len(text) < 50:
                print("    [SKIP] Text too short/unreadable.")
                continue

            # 2. Extract Data (Passing filename for context)
            time.sleep(0.5) 
            data = ask_ollama_extraction(clean_text_for_llm(text), filename)

            if data:
                # 3. Double Check Name (Python Logic Fallback)
                # If AI gave a bad name, or "Unknown", try to grab it from the filename manually
                ai_name = data.get("name", "")
                if not ai_name or "unknown" in ai_name.lower() or any(char.isdigit() for char in ai_name):
                    fallback_name = parse_name_from_filename(filename)
                    if fallback_name:
                        print(f"    [Correction] Replaced '{ai_name}' with filename name: '{fallback_name}'")
                        data['name'] = fallback_name

                # 4. Create VCard Block
                vcard_block = create_vcard_string(data, creation_date)
                vcf_file.write(vcard_block)
                print(f"    -> Added: {data.get('name')} ({data.get('degree')})")
                count += 1
            else:
                print("    -> Failed to extract data.")

    print(f"\nDone! Created {output_filename} with {count} contacts.")

if __name__ == "__main__":
    process_to_vcf()