Upload 18 files

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

CONTRIBUTING.md

@@ -0,0 +1,9 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity, education, socioeconomic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+...
+
+## Enforcement
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the project team at [your-email@example.com].

app.py

@@ -0,0 +1,303 @@
+import gradio as gr
+import os
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+from webdriver_manager.core.os_manager import ChromeType
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import TimeoutException, NoSuchElementException
+from selenium.webdriver.chrome.service import Service
+from webdriver_manager.chrome import ChromeDriverManager
+from openai import OpenAI
+import time
+from docx import Document
+from dotenv import load_dotenv
+import tempfile
+
+# Load environment variables
+load_dotenv(override=True)
+
+# LinkedIn logo as an SVG string
+LINKEDIN_LOGO = """
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="50" height="50">
+    <path fill="#0A66C2" d="M20.447 20.452h-3.554v-5.569c0-1.328-.027-3.037-1.852-3.037-1.853 0-2.136 1.445-2.136 2.939v5.667H9.351V9h3.414v1.561h.046c.477-.9 1.637-1.85 3.37-1.85 3.601 0 4.267 2.37 4.267 5.455v6.286zM5.337 7.433c-1.144 0-2.063-.926-2.063-2.065 0-1.138.92-2.063 2.063-2.063 1.14 0 2.064.925 2.064 2.063 0 1.139-.925 2.065-2.064 2.065zm1.782 13.019H3.555V9h3.564v11.452zM22.225 0H1.771C.792 0 0 .774 0 1.729v20.542C0 23.227.792 24 1.771 24h20.451C23.2 24 24 23.227 24 22.271V1.729C24 .774 23.2 0 22.225 0z"/>
+</svg>
+"""
+
+class LinkedInJDScraper:
+    def __init__(self, email, password):
+        """Initialize the LinkedIn scraper with credentials"""
+        try:
+            options = webdriver.ChromeOptions()
+            options.add_argument('--disable-blink-features=AutomationControlled')
+            options.add_argument('--start-maximized')
+            options.add_argument('--no-sandbox')
+            options.add_argument('--disable-dev-shm-usage')
+            options.add_argument('--headless')
+            options.add_argument('--disable-gpu')
+            options.add_argument('--remote-debugging-port=9222')
+            
+            # Use system ChromeDriver
+            service = Service(executable_path='/usr/bin/chromedriver')
+            
+            self.driver = webdriver.Chrome(service=service, options=options)
+            self.wait = WebDriverWait(self.driver, 10)
+            self.email = email
+            self.password = password
+        except Exception as e:
+            raise Exception(f"Failed to initialize Chrome driver: {str(e)}")
+
+    
+    def login(self):
+        """Login to LinkedIn"""
+        try:
+            self.driver.get("https://www.linkedin.com/login")
+            time.sleep(3)  # Give page time to load
+        
+            # Clear any existing data
+            self.driver.delete_all_cookies()
+        
+            # Add additional headers
+            self.driver.execute_cdp_cmd('Network.setUserAgentOverride', {
+            "userAgent": 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36'
+            })
+        
+            email_field = self.wait.until(
+                EC.presence_of_element_located((By.ID, "username"))
+            )
+            email_field.clear()
+            email_field.send_keys(self.email)
+        
+            password_field = self.driver.find_element(By.ID, "password")
+            password_field.clear()
+            password_field.send_keys(self.password)
+        
+            login_button = self.driver.find_element(By.CSS_SELECTOR, "button[type='submit']")
+            self.driver.execute_script("arguments[0].click();", login_button)
+        
+            time.sleep(5)  # Give more time for login to complete
+        
+            # Verify login success
+            if "feed" in self.driver.current_url or "mynetwork" in self.driver.current_url:
+                return True
+            else:
+                raise Exception("Login verification failed")
+            
+        except Exception as e:
+            return f"Login failed: {str(e)}"
+    
+    def get_description(self, job_url):
+        """Scrape job description from LinkedIn"""
+        max_retries = 3
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                self.driver.get(job_url)
+                time.sleep(5)  # Give more time for the page to load
+                
+                # Check if we're still logged in
+                if "login" in self.driver.current_url.lower():
+                    self.login()
+                    self.driver.get(job_url)
+                    time.sleep(5)
+                
+                # Wait for any one of these selectors to be present
+                description_selectors = [
+                    "div.jobs-description",
+                    "div.jobs-description-content",
+                    "div.jobs-box__html-content",
+                    "div.show-more-less-html__markup"
+                ]
+                
+                description_element = None
+                for selector in description_selectors:
+                    try:
+                        description_element = self.wait.until(
+                            EC.presence_of_element_located((By.CSS_SELECTOR, selector))
+                        )
+                        if description_element:
+                            break
+                    except:
+                        continue
+                
+                if not description_element:
+                    raise NoSuchElementException("Could not find job description element")
+                
+                # Try to expand the description if there's a "show more" button
+                try:
+                    show_more_button = self.driver.find_element(By.CSS_SELECTOR, 
+                        "button.show-more-less-html__button")
+                    if show_more_button.is_displayed():
+                        self.driver.execute_script("arguments[0].click();", show_more_button)
+                        time.sleep(2)
+                except:
+                    pass
+                
+                # Get the text content
+                description = description_element.text
+                
+                if description:
+                    # Try to clean up the description
+                    description = description.strip()
+                    
+                    # Look for common section markers
+                    markers = ["about the job", "job description", "about this role"]
+                    for marker in markers:
+                        start_index = description.lower().find(marker)
+                        if start_index != -1:
+                            description = description[start_index:]
+                            break
+                    
+                    return description
+                
+                retry_count += 1
+                time.sleep(3)  # Increased wait between retries
+                
+            except Exception as e:
+                print(f"Attempt {retry_count + 1} failed: {str(e)}")
+                retry_count += 1
+                time.sleep(3)
+                
+        return "Failed to retrieve job description after multiple attempts"
+        
+def read_resume(file_obj):
+    """Read resume content from uploaded file"""
+    try:
+        # Get the file path directly from the Gradio file object
+        file_path = file_obj.name
+        
+        # Read the document directly from the path
+        doc = Document(file_path)
+        text = []
+        for paragraph in doc.paragraphs:
+            if paragraph.text.strip():
+                text.append(paragraph.text.strip())
+        
+        return "\n".join(text)
+    except Exception as e:
+        return f"Error reading resume: {str(e)}"
+
+
+def generate_cover_letter(linkedin_email, linkedin_password, job_url, resume_file):
+    """Generate cover letter based on job description and resume"""
+    
+    # Input validation
+    if not all([linkedin_email, linkedin_password, job_url]):
+        return "Please fill in all required fields (LinkedIn email, password, and job URL)"
+    
+    if not resume_file:
+        return "Please upload a resume file"
+    
+    try:
+        # Initialize scraper and get job description
+        scraper = LinkedInJDScraper(linkedin_email, linkedin_password)
+        login_result = scraper.login()
+        
+        if isinstance(login_result, str) and "failed" in login_result.lower():
+            scraper.close()
+            return login_result
+        
+        # Get job description
+        job_description = scraper.get_description(job_url)
+        scraper.close()
+        
+        if "Failed to retrieve" in job_description:
+            return job_description
+        
+        # Read resume
+        resume_content = read_resume(resume_file)
+        if "Error reading resume" in resume_content:
+            return resume_content
+        
+        # Prepare prompts
+        system_prompt = """
+        You are a career assistant specialized in crafting professional and personalized cover letters. 
+        Your goal is to create compelling, tailored cover letters that align with the job description. 
+        Each cover letter should emphasize the user's qualifications, skills, and experiences while maintaining a professional tone and structure.
+        """
+        
+        user_prompt = f"""
+        Create a professional cover letter based on:
+        
+        Resume content:
+        {resume_content}
+        
+        Job Description:
+        {job_description}
+        
+        Make the cover letter specific to the role and highlight relevant experience.
+        """
+        
+        # Generate cover letter using OpenAI
+        api_key = os.getenv('OPENAI_API_KEY')
+        if not api_key:
+            return "OpenAI API key not found. Please check your .env file."
+            
+        client = OpenAI(api_key=api_key)
+        response = client.chat.completions.create(
+            model="gpt-4",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+        return response.choices[0].message.content
+        
+    except Exception as e:
+        return f"Error generating cover letter: {str(e)}"
+    finally:
+        # Ensure browser is closed
+        if 'scraper' in locals():
+            scraper.close()
+
+def create_gradio_interface():
+    """Create and configure the Gradio interface"""
+    with gr.Blocks(title="LinkedIn Cover Letter Generator") as app:
+        # Header with logo and title
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.HTML(LINKEDIN_LOGO)
+            with gr.Column(scale=4):
+                gr.Markdown("# LinkedIn Cover Letter Generator")
+        
+        with gr.Row():
+            with gr.Column():
+                linkedin_email = gr.Textbox(
+                    label="LinkedIn Email",
+                    placeholder="Enter your LinkedIn email"
+                )
+                linkedin_password = gr.Textbox(
+                    label="LinkedIn Password",
+                    type="password",
+                    placeholder="Enter your LinkedIn password"
+                )
+                job_url = gr.Textbox(
+                    label="LinkedIn Job URL",
+                    placeholder="Paste the LinkedIn job posting URL"
+                )
+                resume_file = gr.File(
+                    label="Upload Resume (DOCX)",
+                    file_types=[".docx"]
+                )
+                
+                generate_button = gr.Button("Generate Cover Letter", variant="primary")
+            
+            with gr.Column():
+                output = gr.Markdown(label="Generated Cover Letter")
+        
+        generate_button.click(
+            fn=generate_cover_letter,
+            inputs=[linkedin_email, linkedin_password, job_url, resume_file],
+            outputs=output
+        )
+    
+    return app
+
+# Main execution
+if __name__ == "__main__":
+    # Create and launch the Gradio app
+    app = create_gradio_interface()
+    app.launch(share=True)

cover_letter_generator/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

cover_letter_generator/README.md

@@ -0,0 +1,14 @@
+---
+title: Cover Letter Generator
+emoji: 💬
+colorFrom: yellow
+colorTo: purple
+sdk: gradio
+sdk_version: 5.0.1
+app_file: app.py
+pinned: false
+license: mit
+short_description: Create your cover letter for LinkedIn Jobs
+---
+
+An example chatbot using [Gradio](https://gradio.app), [`huggingface_hub`](https://huggingface.co/docs/huggingface_hub/v0.22.2/en/index), and the [Hugging Face Inference API](https://huggingface.co/docs/api-inference/index).

cover_letter_generator/app.py

@@ -0,0 +1,64 @@
+import gradio as gr
+from huggingface_hub import InferenceClient
+
+"""
+For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+"""
+client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+
+
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+):
+    messages = [{"role": "system", "content": system_message}]
+
+    for val in history:
+        if val[0]:
+            messages.append({"role": "user", "content": val[0]})
+        if val[1]:
+            messages.append({"role": "assistant", "content": val[1]})
+
+    messages.append({"role": "user", "content": message})
+
+    response = ""
+
+    for message in client.chat_completion(
+        messages,
+        max_tokens=max_tokens,
+        stream=True,
+        temperature=temperature,
+        top_p=top_p,
+    ):
+        token = message.choices[0].delta.content
+
+        response += token
+        yield response
+
+
+"""
+For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
+"""
+demo = gr.ChatInterface(
+    respond,
+    additional_inputs=[
+        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(
+            minimum=0.1,
+            maximum=1.0,
+            value=0.95,
+            step=0.05,
+            label="Top-p (nucleus sampling)",
+        ),
+    ],
+)
+
+
+if __name__ == "__main__":
+    demo.launch()

cover_letter_generator/requirements.txt

@@ -0,0 +1 @@
+huggingface_hub==0.25.2

generator.py

@@ -0,0 +1,86 @@
+
+import os
+from docx import Document
+from dotenv import load_dotenv
+from openai import OpenAI
+
+class CVGenerator:
+    def __init__(self):
+        # Load API key for OpenAI
+        load_dotenv()
+        self.api_key = os.getenv("OPENAI_API_KEY")
+        if not self.api_key:
+            raise ValueError("OpenAI API key not found. Please set it in the .env file.")
+        self.model = OpenAI(api_key=self.api_key)
+
+    def generate_cv(self, job_description, user_details):
+        """
+        Generates a tailored CV based on the job description and user details.
+
+        :param job_description: Text of the job description.
+        :param user_details: Dictionary containing user information (name, skills, experience, etc.).
+        :return: A formatted CV as a string.
+        """
+        prompt = f"""
+        Create a tailored CV for the following job description and user details:
+        
+        Job Description:
+        {job_description}
+        
+        User Details:
+        {user_details}
+        
+        The CV should be professional and formatted for ATS (Applicant Tracking Systems). Include the following sections:
+        - Contact Information
+        - Professional Summary
+        - Skills
+        - Work Experience
+        - Education
+        - Certifications (if any)
+        - References (if provided)
+        """
+        
+        response = self.model.generate(prompt, model="gpt-4", max_tokens=1500)
+        return response.get("choices")[0].get("text").strip()
+
+    def save_cv(self, cv_text, file_name="Tailored_CV.docx"):
+        """
+        Saves the CV text to a Word document.
+
+        :param cv_text: The CV content as plain text.
+        :param file_name: The name of the file to save the CV.
+        """
+        doc = Document()
+        doc.add_paragraph(cv_text)
+        doc.save(file_name)
+        print(f"CV saved as {file_name}")
+
+if __name__ == "__main__":
+    # Example usage
+    generator = CVGenerator()
+
+    # Sample job description and user details
+    job_description = "We are looking for a data scientist skilled in Python, machine learning, and data visualization."
+    user_details = {
+        "name": "John Doe",
+        "email": "john.doe@example.com",
+        "phone": "123-456-7890",
+        "skills": ["Python", "Machine Learning", "Data Visualization", "SQL", "R"],
+        "experience": [
+            {
+                "title": "Data Analyst",
+                "company": "ABC Corp",
+                "duration": "Jan 2020 - Dec 2022",
+                "responsibilities": [
+                    "Analyzed large datasets to generate actionable insights.",
+                    "Developed predictive models to optimize business processes."
+                ]
+            }
+        ],
+        "education": "M.S. in Data Science, XYZ University",
+        "certifications": ["Certified Data Scientist"],
+    }
+
+    # Generate and save the CV
+    cv_text = generator.generate_cv(job_description, user_details)
+    generator.save_cv(cv_text)

main.py

@@ -0,0 +1,212 @@
+import os 
+import requests 
+import json 
+from typing import List 
+from openai import OpenAI
+from dotenv import load_dotenv
+from bs4 import BeautifulSoup 
+from IPython.display import Markdown, display, update_display 
+from openai import OpenAI
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import TimeoutException, NoSuchElementException
+import time
+from docx import Document
+
+# Initialize and constants
+load_dotenv(override=True)
+api_key = os.getenv('OPENAI_API_KEY')
+
+if api_key and api_key.startswith('sk-proj-') and len(api_key) > 10: 
+    print("API key looks good so far") 
+else: 
+    print("There might be a problem with API key, Please Check") 
+
+MODEL_GPT = 'gpt-4o-mini'
+openai = OpenAI()
+
+class LinkedInJDScraper:
+    def __init__(self, email, password):
+        options = webdriver.ChromeOptions()
+        options.add_argument('--disable-blink-features=AutomationControlled')
+        options.add_argument('--start-maximized')
+        # Add these options to prevent infinite loops
+        options.add_argument('--no-sandbox')
+        options.add_argument('--disable-dev-shm-usage')
+        
+        self.driver = webdriver.Chrome(options=options)
+        self.wait = WebDriverWait(self.driver, 10)  # Reduced wait time
+        self.email = email
+        self.password = password
+    
+    def login(self):
+        try:
+            self.driver.get("https://www.linkedin.com/login")
+            
+            # Wait for email field with timeout
+            email_field = self.wait.until(
+                EC.presence_of_element_located((By.ID, "username"))
+            )
+            email_field.send_keys(self.email)
+            
+            # Find password field
+            password_field = self.driver.find_element(By.ID, "password")
+            password_field.send_keys(self.password)
+            
+            # Find and click login button
+            login_button = self.driver.find_element(By.CSS_SELECTOR, "button[type='submit']")
+            login_button.click()
+            
+            # Wait for login to complete with timeout
+            time.sleep(3)
+            return True
+            
+        except Exception as e:
+            print(f"Login failed: {str(e)}")
+            return False
+    
+    def get_description(self, job_url):
+        max_retries = 3
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                # Navigate to job page
+                self.driver.get(job_url)
+                
+                # Wait for any description element to be present
+                self.wait.until(
+                    EC.presence_of_element_located((By.CSS_SELECTOR, "div.jobs-description"))
+                )
+                
+                # Try to click "Show more" if it exists
+                try:
+                    show_more = self.wait.until(
+                        EC.presence_of_element_located((By.CSS_SELECTOR, "button.show-more-less-html__button"))
+                    )
+                    if show_more.is_displayed():
+                        show_more.click()
+                        time.sleep(1)
+                except (TimeoutException, NoSuchElementException):
+                    pass
+                
+                # Get description text
+                description_element = self.driver.find_element(By.CSS_SELECTOR, "div.jobs-description")
+                description = description_element.text
+                
+                if description:
+                    # Find start of job description
+                    start_index = description.lower().find("about the job")
+                    if start_index != -1:
+                        return description[start_index:]
+                    return description
+                
+                retry_count += 1
+                time.sleep(2)
+                
+            except Exception as e:
+                print(f"Attempt {retry_count + 1} failed: {str(e)}")
+                retry_count += 1
+                time.sleep(2)
+                
+        return "Failed to retrieve job description after multiple attempts"
+    
+    def close(self):
+        try:
+            self.driver.quit()
+        except:
+            pass
+
+if __name__ == "__main__":
+    EMAIL = os.getenv('LINKEDIN_EMAIL')
+    PASSWORD = os.getenv('LINKEDIN_PASSWORD')
+    
+    scraper = LinkedInJDScraper(EMAIL, PASSWORD)
+    
+    try:
+        if scraper.login():
+            job_url = "https://www.linkedin.com/jobs/view/4109295398"
+            description = scraper.get_description(job_url)
+            print("\nJob Description:")
+            print(description)
+        else:
+            print("Failed to login. Please check your credentials.")
+    finally:
+        scraper.close()
+
+system_prompt = """
+You are a career assistant specialized in crafting professional and personalized cover letters. 
+Your goal is to create compelling, tailored cover letters that align with the job description. 
+Each cover letter should emphasize the user’s qualifications, skills, and experiences while maintaining a professional tone and structure. 
+Ensure the letter adheres to the following format:
+
+1. **Introduction**: A brief and enthusiastic introduction expressing interest in the role and organization.
+2. **Body**: Highlight relevant skills, experiences, and achievements that align with the job description. Use specific examples when possible.
+3. **Closing**: Reiterate enthusiasm for the role, express willingness to contribute to the organization, and include a polite call to action.
+
+Maintain clarity, professionalism, and conciseness while tailoring the letter. Don't add anything like as advertised.
+"""
+
+
+def read_text_from_word(file_path):
+    """Extracts and returns all text from a Word document."""
+    # Load the document
+    doc = Document(file_path)
+    
+    # Extract text from each paragraph
+    text = []
+    for paragraph in doc.paragraphs:
+        if paragraph.text.strip():  # Skip empty lines
+            text.append(paragraph.text.strip())
+    
+    return "\n".join(text)
+
+file_path = "Sample_Resume.docx"  # Replace with your file path
+resume_skills = read_text_from_word(file_path)
+
+print(resume_skills)
+
+def get_cl_user_prompt_with_scraped_jd(job_url, scraper, resume_skills):
+    # Scrape job description
+    description = scraper.scrape_job_descriptions([job_url]).get(job_url)
+
+    # Construct the prompt
+    user_prompt = "You are tasked with creating a professional and tailored Cover Letter for a job application.\n"
+    user_prompt += "Here is a list of skills and experiences from the candidate's resume:\n"
+    user_prompt += f"{resume_skills}\n\n"
+    user_prompt += "Here is the job description for the position they are applying for:\n"
+    user_prompt += f"{description}\n\n"
+    user_prompt += (
+        "Using the skills from the candidate's resume, craft a CL that highlights their most relevant qualifications "
+        "and experiences for this job making use of job description. "
+        "Ensure the CV follows a professional format and aligns with the role requirements. Present the CV in markdown format.\n"
+    )
+    return user_prompt
+
+def create_jd(system_prompt, file_path, job_url, scraper, model="gpt-4"):
+    try:
+        # Generate user prompt
+        user_prompt = get_cl_user_prompt_with_scraped_jd(file_path, job_url, scraper)
+
+        # OpenAI API call
+        completion = openai.ChatCompletion.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+        )
+
+        # Extract and display the result
+        result = completion.choices[0].message.content
+        display(Markdown(result))
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+
+messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": get_cl_user_prompt_with_scraped_jd(file_path, job_url, scraper) }]
+response = openai.chat.completions.create(model="gpt-4o-mini", messages=messages)
+print(response.choices[0].message.content)
+

packages.txt

@@ -0,0 +1,2 @@
+chromium
+chromium-driver

project.ipynb

@@ -0,0 +1,468 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os \n",
+    "import requests \n",
+    "import json \n",
+    "from typing import List \n",
+    "from dotenv import load_dotenv\n",
+    "from bs4 import BeautifulSoup \n",
+    "from IPython.display import Markdown, display, update_display \n",
+    "from openai import OpenAI\n",
+    "from selenium import webdriver\n",
+    "from selenium.webdriver.common.by import By\n",
+    "from selenium.webdriver.support.ui import WebDriverWait\n",
+    "from selenium.webdriver.support import expected_conditions as EC\n",
+    "from selenium.common.exceptions import TimeoutException, NoSuchElementException\n",
+    "import time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "API key looks good so far\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Initialize and constants\n",
+    "load_dotenv(override=True)\n",
+    "api_key = os.getenv('OPENAI_API_KEY')\n",
+    "\n",
+    "if api_key and api_key.startswith('sk-proj-') and len(api_key) > 10: \n",
+    "    print(\"API key looks good so far\") \n",
+    "else: \n",
+    "    print(\"There might be a problem with API key, Please Check\") \n",
+    "\n",
+    "MODEL_GPT = 'gpt-4o-mini'\n",
+    "openai = OpenAI()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Job Description:\n",
+      "About the job\n",
+      "Description\n",
+      "\n",
+      "Are you looking to work at the forefront of Machine Learning and AI? Would you be excited to apply cutting edge Generative AI algorithms to solve real world problems with significant impact? The AWS Industries Team at AWS helps AWS customers implement Generative AI solutions and realize transformational business opportunities for AWS customers in the most strategic industry verticals. This is a team of data scientists, engineers, and architects working step-by-step with customers to build bespoke solutions that harness the power of generative AI.\n",
+      "\n",
+      "The team helps customers imagine and scope the use cases that will create the greatest value for their businesses, select and train and fine tune the right models, define paths to navigate technical or business challenges, develop proof-of-concepts, and build applications to launch these solutions at scale. The AWS Industries team provides guidance and implements best practices for applying generative AI responsibly and cost efficiently.\n",
+      "\n",
+      "You will work directly with customers and innovate in a fast-paced organization that contributes to game-changing projects and technologies. You will design and run experiments, research new algorithms, and find new ways of optimizing risk, profitability, and customer experience.\n",
+      "\n",
+      "In this Data Scientist role you will be capable of using GenAI and other techniques to design, evangelize, and implement and scale cutting-edge solutions for never-before-solved problems.\n",
+      "\n",
+      "Key job responsibilities\n",
+      "\n",
+      "As a Data Scientist, you will-\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "ABOUT AWS:\n",
+      "\n",
+      "Diverse Experiences\n",
+      "\n",
+      "Amazon values diverse experiences. Even if you do not meet all of the preferred qualifications and skills listed in the job description, we encourage candidates to apply. If your career is just starting, hasn’t followed a traditional path, or includes alternative experiences, don’t let it stop you from applying.\n",
+      "\n",
+      "Why AWS\n",
+      "\n",
+      "Amazon Web Services (AWS) is the world’s most comprehensive and broadly adopted cloud platform. We pioneered cloud computing and never stopped innovating — that’s why customers from the most successful startups to Global 500 companies trust our robust suite of products and services to power their businesses.\n",
+      "\n",
+      "Work/Life Balance\n",
+      "\n",
+      "We value work-life harmony. Achieving success at work should never come at the expense of sacrifices at home, which is why we strive for flexibility as part of our working culture. When we feel supported in the workplace and at home, there’s nothing we can’t achieve in the cloud.\n",
+      "\n",
+      "Inclusive Team Culture\n",
+      "\n",
+      "Here at AWS, it’s in our nature to learn and be curious. Our employee-led affinity groups foster a culture of inclusion that empower us to be proud of our differences. Ongoing events and learning experiences, including our Conversations on Race and Ethnicity (CORE) and AmazeCon (gender diversity) conferences, inspire us to never stop embracing our uniqueness.\n",
+      "\n",
+      "Mentorship and Career Growth\n",
+      "\n",
+      "We’re continuously raising our performance bar as we strive to become Earth’s Best Employer. That’s why you’ll find endless knowledge-sharing, mentorship and other career-advancing resources here to help you develop into a better-rounded professional.\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "Amazon is committed to a diverse and inclusive workplace. Amazon is an equal opportunity employer and does not discriminate on the basis of race, national origin, gender, gender identity, sexual orientation, protected veteran status, disability, age, or other legally protected status. For individuals with disabilities who would like to request an accommodation, please visit https://www.amazon.jobs/en/disability/us.\n",
+      "\n",
+      "Los Angeles County applicants: Job duties for this position include: work safely and cooperatively with other employees, supervisors, and staff; adhere to standards of excellence despite stressful conditions; communicate effectively and respectfully with employees, supervisors, and staff to ensure exceptional customer service; and follow all federal, state, and local laws and Company policies. Criminal history may have a direct, adverse, and negative relationship with some of the material job duties of this position. These include the duties and responsibilities listed above, as well as the abilities to adhere to company policies, exercise sound judgment, effectively manage stress and work safely and respectfully with others, exhibit trustworthiness and professionalism, and safeguard business operations and the Company’s reputation. Pursuant to the Los Angeles County Fair Chance Ordinance, we will consider for employment qualified applicants with arrest and conviction records.\n",
+      "\n",
+      "Our compensation reflects the cost of labor across several US geographic markets. The base pay for this position ranges from $125,500/year in our lowest geographic market up to $212,800/year in our highest geographic market. Pay is based on a number of factors including market location and may vary depending on job-related knowledge, skills, and experience. Amazon is a total compensation company. Dependent on the position offered, equity, sign-on payments, and other forms of compensation may be provided as part of a total compensation package, in addition to a full range of medical, financial, and/or other benefits. For more information, please visit https://www.aboutamazon.com/workplace/employee-benefits. This position will remain posted until filled. Applicants should apply via our internal or external career site.\n",
+      "\n",
+      "\n",
+      "- Amazon Web Services, Inc.\n",
+      "\n",
+      "Job ID: A2800210\n",
+      "See more\n"
+     ]
+    }
+   ],
+   "source": [
+    "class LinkedInJDScraper:\n",
+    "    def __init__(self, email, password):\n",
+    "        options = webdriver.ChromeOptions()\n",
+    "        options.add_argument('--disable-blink-features=AutomationControlled')\n",
+    "        options.add_argument('--start-maximized')\n",
+    "        # Add these options to prevent infinite loops\n",
+    "        options.add_argument('--no-sandbox')\n",
+    "        options.add_argument('--disable-dev-shm-usage')\n",
+    "        \n",
+    "        self.driver = webdriver.Chrome(options=options)\n",
+    "        self.wait = WebDriverWait(self.driver, 10)  # Reduced wait time\n",
+    "        self.email = email\n",
+    "        self.password = password\n",
+    "    \n",
+    "    def login(self):\n",
+    "        try:\n",
+    "            self.driver.get(\"https://www.linkedin.com/login\")\n",
+    "            \n",
+    "            # Wait for email field with timeout\n",
+    "            email_field = self.wait.until(\n",
+    "                EC.presence_of_element_located((By.ID, \"username\"))\n",
+    "            )\n",
+    "            email_field.send_keys(self.email)\n",
+    "            \n",
+    "            # Find password field\n",
+    "            password_field = self.driver.find_element(By.ID, \"password\")\n",
+    "            password_field.send_keys(self.password)\n",
+    "            \n",
+    "            # Find and click login button\n",
+    "            login_button = self.driver.find_element(By.CSS_SELECTOR, \"button[type='submit']\")\n",
+    "            login_button.click()\n",
+    "            \n",
+    "            # Wait for login to complete with timeout\n",
+    "            time.sleep(3)\n",
+    "            return True\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            print(f\"Login failed: {str(e)}\")\n",
+    "            return False\n",
+    "    \n",
+    "    def get_description(self, job_url):\n",
+    "        max_retries = 3\n",
+    "        retry_count = 0\n",
+    "        \n",
+    "        while retry_count < max_retries:\n",
+    "            try:\n",
+    "                # Navigate to job page\n",
+    "                self.driver.get(job_url)\n",
+    "                \n",
+    "                # Wait for any description element to be present\n",
+    "                self.wait.until(\n",
+    "                    EC.presence_of_element_located((By.CSS_SELECTOR, \"div.jobs-description\"))\n",
+    "                )\n",
+    "                \n",
+    "                # Try to click \"Show more\" if it exists\n",
+    "                try:\n",
+    "                    show_more = self.wait.until(\n",
+    "                        EC.presence_of_element_located((By.CSS_SELECTOR, \"button.show-more-less-html__button\"))\n",
+    "                    )\n",
+    "                    if show_more.is_displayed():\n",
+    "                        show_more.click()\n",
+    "                        time.sleep(1)\n",
+    "                except (TimeoutException, NoSuchElementException):\n",
+    "                    pass\n",
+    "                \n",
+    "                # Get description text\n",
+    "                description_element = self.driver.find_element(By.CSS_SELECTOR, \"div.jobs-description\")\n",
+    "                description = description_element.text\n",
+    "                \n",
+    "                if description:\n",
+    "                    # Find start of job description\n",
+    "                    start_index = description.lower().find(\"about the job\")\n",
+    "                    if start_index != -1:\n",
+    "                        return description[start_index:]\n",
+    "                    return description\n",
+    "                \n",
+    "                retry_count += 1\n",
+    "                time.sleep(2)\n",
+    "                \n",
+    "            except Exception as e:\n",
+    "                print(f\"Attempt {retry_count + 1} failed: {str(e)}\")\n",
+    "                retry_count += 1\n",
+    "                time.sleep(2)\n",
+    "                \n",
+    "        return \"Failed to retrieve job description after multiple attempts\"\n",
+    "    \n",
+    "    def close(self):\n",
+    "        try:\n",
+    "            self.driver.quit()\n",
+    "        except:\n",
+    "            pass\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    EMAIL = os.getenv('LINKEDIN_EMAIL')\n",
+    "    PASSWORD = os.getenv('LINKEDIN_PASSWORD')\n",
+    "    \n",
+    "    scraper = LinkedInJDScraper(EMAIL, PASSWORD)\n",
+    "    \n",
+    "    try:\n",
+    "        if scraper.login():\n",
+    "            job_url = \"https://www.linkedin.com/jobs/view/4109295398\"\n",
+    "            description = scraper.get_description(job_url)\n",
+    "            print(\"\\nJob Description:\")\n",
+    "            print(description)\n",
+    "        else:\n",
+    "            print(\"Failed to login. Please check your credentials.\")\n",
+    "    finally:\n",
+    "        scraper.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_prompt = \"\"\"\n",
+    "You are a career assistant specialized in crafting professional and personalized cover letters. \n",
+    "Your goal is to create compelling, tailored cover letters that align with the job description. \n",
+    "Each cover letter should emphasize the user’s qualifications, skills, and experiences while maintaining a professional tone and structure. \n",
+    "Ensure the letter adheres to the following format:\n",
+    "\n",
+    "1. **Introduction**: A brief and enthusiastic introduction expressing interest in the role and organization.\n",
+    "2. **Body**: Highlight relevant skills, experiences, and achievements that align with the job description. Use specific examples when possible.\n",
+    "3. **Closing**: Reiterate enthusiasm for the role, express willingness to contribute to the organization, and include a polite call to action.\n",
+    "\n",
+    "Maintain clarity, professionalism, and conciseness while tailoring the letter. Don't add anything like as advertised.\n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "John Doe\n",
+      "john.doe@example.com | +1 123-456-7890 | linkedin.com/in/johndoe\n",
+      "EDUCATION\n",
+      "•\tMaster of Science in Computer Science\n",
+      "Stanford University, Stanford, CA\n",
+      "September 2016 – June 2018\n",
+      "GPA: 3.9/4.0\n",
+      "•\tBachelor of Science in Statistics\n",
+      "University of California, Berkeley, CA\n",
+      "August 2012 – May 2016\n",
+      "GPA: 3.8/4.0\n",
+      "PROFESSIONAL EXPERIENCE\n",
+      "•\tData Scientist\n",
+      "Meta Platforms, Inc., Menlo Park, CA\n",
+      "July 2018 – Present\n",
+      "•\tDeveloped and deployed machine learning models to enhance user engagement, resulting in a 15% increase in active user retention over 12 months.\n",
+      "•\tLed a cross-functional team to implement a recommendation system for personalized content delivery, boosting click-through rates by 20%.\n",
+      "•\tConducted A/B testing and statistical analysis to inform product decisions, contributing to a 10% improvement in ad revenue.\n",
+      "•\tOptimized data pipelines using SQL and Python, reducing data processing time by 30%.\n",
+      "•\tMentored junior data scientists and conducted training sessions on advanced analytics techniques.\n",
+      "PROJECTS\n",
+      "•\tReal-Time Fraud Detection System\n",
+      "Designed and implemented a real-time fraud detection system using anomaly detection algorithms, reducing fraudulent activities by 25%.\n",
+      "•\tCustomer Segmentation Analysis\n",
+      "Performed clustering analysis to segment customers, enabling targeted marketing strategies that increased conversion rates by 18%.\n",
+      "•\tNatural Language Processing for Sentiment Analysis\n",
+      "Developed an NLP model to analyze customer feedback, providing insights that improved customer satisfaction scores by 12%.\n",
+      "SKILLS\n",
+      "•\tProgramming Languages: Python, R, SQL, Java\n",
+      "•\tMachine Learning Frameworks: TensorFlow, PyTorch, Scikit-learn\n",
+      "•\tData Visualization Tools: Tableau, Matplotlib, Seaborn\n",
+      "•\tBig Data Technologies: Hadoop, Spark\n",
+      "•\tDatabases: MySQL, PostgreSQL, MongoDB\n",
+      "•\tTools & Platforms: Git, Docker, AWS, Azure\n",
+      "CERTIFICATIONS\n",
+      "•\tCertified Data Scientist\n",
+      "Data Science Council of America (DASCA)\n",
+      "Issued June 2018\n",
+      "•\tMachine Learning Specialization\n",
+      "Coursera – Stanford University\n",
+      "Completed May 2017\n",
+      "ACHIEVEMENTS\n",
+      "•\tRecognized as “Employee of the Quarter” for Q2 2020 at Meta for outstanding contributions to the data science team.\n",
+      "•\tPublished research on machine learning algorithms in the Journal of Data Science (March 2019).\n",
+      "•\tSpeaker at the 2021 International Conference on Data Mining, presenting on scalable data pipeline architectures.\n",
+      "If you need this content in a DOCX file, please let me know, and I can provide a download link for you.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from docx import Document\n",
+    "\n",
+    "def read_text_from_word(file_path):\n",
+    "    \"\"\"Extracts and returns all text from a Word document.\"\"\"\n",
+    "    # Load the document\n",
+    "    doc = Document(file_path)\n",
+    "    \n",
+    "    # Extract text from each paragraph\n",
+    "    text = []\n",
+    "    for paragraph in doc.paragraphs:\n",
+    "        if paragraph.text.strip():  # Skip empty lines\n",
+    "            text.append(paragraph.text.strip())\n",
+    "    \n",
+    "    return \"\\n\".join(text)\n",
+    "\n",
+    "# Example Usage\n",
+    "file_path = \"Sample_Resume.docx\"  # Replace with your file path\n",
+    "resume_skills = read_text_from_word(file_path)\n",
+    "\n",
+    "print(resume_skills)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_cl_user_prompt_with_scraped_jd(file_path, job_url, scraper):\n",
+    "    \"\"\"\n",
+    "    Generate a user prompt for CL creation using scraped job description \n",
+    "    and skills from a Word document.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # # Scrape the job description\n",
+    "    # job_description = scraper.get_description(job_url)\n",
+    "    \n",
+    "    # Create the user prompt\n",
+    "    user_prompt = \"You are tasked with creating a professional and tailored Cover Letter for a job application.\\n\"\n",
+    "    user_prompt += \"Here is a list of skills and experiences from the candidate's resume:\\n\"\n",
+    "    user_prompt += f\"{resume_skills}\\n\\n\"\n",
+    "    user_prompt += \"Here is the job description for the position they are applying for:\\n\"\n",
+    "    user_prompt += f\"{description}\\n\\n\"\n",
+    "    user_prompt += \"Using the skills from the candidate's resume, craft a CL that highlights their most relevant qualifications and experiences for this job making use of job description. \"\n",
+    "    user_prompt += \"Ensure the CV follows a professional format and aligns with the role requirements. Present the CV in markdown format.\\n\"\n",
+    "    user_prompt = user_prompt \n",
+    "    return user_prompt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from IPython.display import Markdown, display\n",
+    "\n",
+    "def create_jd(system_prompt, file_path, job_url, scraper, model=\"gpt-4\"):\n",
+    "\n",
+    "        # OpenAI API call\n",
+    "        completion = openai.ChatCompletion.create(\n",
+    "            model=model,\n",
+    "            messages=[\n",
+    "                {\"role\": \"system\", \"content\": system_prompt},\n",
+    "                {\"role\": \"user\", \"content\": get_cl_user_prompt_with_scraped_jd(file_path, job_url, scraper)}\n",
+    "            ]\n",
+    "        )\n",
+    "\n",
+    "        # Extract and display the result\n",
+    "        result = completion.choices[0].message.content\n",
+    "        display(Markdown(result))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "messages=[{\"role\": \"system\", \"content\": system_prompt}, {\"role\": \"user\", \"content\": get_cl_user_prompt_with_scraped_jd(file_path, job_url, scraper) }]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "```markdown\n",
+      "John Doe  \n",
+      "john.doe@example.com | +1 123-456-7890 | linkedin.com/in/johndoe  \n",
+      "\n",
+      "[Date]  \n",
+      "\n",
+      "Hiring Manager  \n",
+      "Amazon Web Services, Inc.  \n",
+      "[Company Address]  \n",
+      "[City, State, Zip]  \n",
+      "\n",
+      "Dear Hiring Manager,\n",
+      "\n",
+      "I am writing to express my enthusiasm for the Data Scientist position within the AWS Industries Team, as advertised. With a strong foundation in machine learning, data analytics, and a proven track record of developing innovative solutions to enhance user engagement, I am excited about the opportunity to contribute to cutting-edge projects at Amazon Web Services.\n",
+      "\n",
+      "During my time as a Data Scientist at Meta Platforms, Inc., I developed and deployed machine learning models that significantly increased active user retention by 15%. Leading a cross-functional team to implement a personalized content recommendation system, I contributed to a 20% boost in click-through rates, showcasing my ability to drive substantial improvements through the application of advanced analytics. My experience in conducting A/B testing and statistical analysis allowed me to make informed product decisions, resulting in a 10% increase in ad revenue—a key aspect that aligns with AWS's commitment to optimizing customer experience and profitability.\n",
+      "\n",
+      "One of my most impactful projects involved designing a real-time fraud detection system using anomaly detection algorithms, reducing fraudulent activities by 25%. This aligns with the responsibilities of the AWS Industries Team to develop bespoke solutions that tackle complex problems effectively. Additionally, my clustering analysis for customer segmentation led to targeted marketing strategies that increased conversion rates by 18%, demonstrating my capacity to innovate and tailor solutions to specific business needs.\n",
+      "\n",
+      "I am particularly drawn to the emphasis on generative AI within the AWS Industries Team. My background in programming languages such as Python, R, and SQL, combined with experience using machine learning frameworks like TensorFlow and PyTorch, prepares me well for designing and implementing generative AI solutions. Furthermore, my capability to optimize data pipelines using tools like Hadoop and Spark ensures that I can provide efficient and scalable solutions for AWS clients.\n",
+      "\n",
+      "The opportunity to work with diverse teams, guiding clients through the implementation of generative AI solutions, excites me greatly. I am eager to leverage my skills to help AWS customers realize transformational business opportunities while adhering to the principles of responsible and cost-efficient implementation.\n",
+      "\n",
+      "Thank you for considering my application. I am excited about the possibility of contributing to the innovative work at AWS and would welcome the opportunity to discuss my application further. I look forward to the chance to speak with you soon.\n",
+      "\n",
+      "Warm regards,\n",
+      "\n",
+      "John Doe\n",
+      "```\n"
+     ]
+    }
+   ],
+   "source": [
+    "# To give you a preview -- calling OpenAI with system and user messages:\n",
+    "\n",
+    "response = openai.chat.completions.create(model=\"gpt-4o-mini\", messages=messages)\n",
+    "print(response.choices[0].message.content)"
+   ]
+  }
+ ],
+ "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.12.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

requirements.txt

@@ -0,0 +1,8 @@
+requests==2.32.3
+openai==1.57.4
+python-docx==1.1.2
+python-dotenv==1.0.1
+beautifulsoup4==4.12.3
+selenium==4.27.1
+gradio==3.50
+webdriver_manager==4.0.1

resume_reader.py

@@ -0,0 +1,19 @@
+from docx import Document
+
+def read_text_from_word(file_path):
+    """Extracts and returns all text from a Word document."""
+    # Load the document
+    doc = Document(file_path)
+    
+    # Extract text from each paragraph
+    text = []
+    for paragraph in doc.paragraphs:
+        if paragraph.text.strip():  # Skip empty lines
+            text.append(paragraph.text.strip())
+    
+    return "\n".join(text)
+
+file_path = "Sample_Resume.docx"  # Replace with your file path
+resume_skills = read_text_from_word(file_path)
+
+print(resume_skills)

scraper.py

@@ -0,0 +1,66 @@
+
+import os
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import TimeoutException, NoSuchElementException
+from bs4 import BeautifulSoup
+from dotenv import load_dotenv
+
+class LinkedInJDScraper:
+    def __init__(self, email, password):
+        # Initialize the Selenium WebDriver
+        options = webdriver.ChromeOptions()
+        options.add_argument("--headless")
+        self.driver = webdriver.Chrome(options=options)
+        self.email = email
+        self.password = password
+
+    def login(self):
+        # Login to LinkedIn
+        try:
+            self.driver.get("https://www.linkedin.com/login")
+            WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "username")))
+            self.driver.find_element(By.ID, "username").send_keys(self.email)
+            self.driver.find_element(By.ID, "password").send_keys(self.password)
+            self.driver.find_element(By.XPATH, '//button[@type="submit"]').click()
+        except TimeoutException:
+            print("Login page did not load in time.")
+
+    def scrape_job_descriptions(self, job_urls):
+        # Scrape job descriptions from provided LinkedIn job URLs
+        job_descriptions = {}
+        for url in job_urls:
+            try:
+                self.driver.get(url)
+                WebDriverWait(self.driver, 10).until(
+                    EC.presence_of_element_located((By.CLASS_NAME, "jobs-description-content"))
+                )
+                page_source = self.driver.page_source
+                soup = BeautifulSoup(page_source, "html.parser")
+                description = soup.find("div", class_="jobs-description-content").get_text(strip=True)
+                job_descriptions[url] = description
+            except (TimeoutException, NoSuchElementException) as e:
+                print(f"Error scraping {url}: {e}")
+                job_descriptions[url] = None
+        return job_descriptions
+
+    def close(self):
+        # Close the WebDriver
+        self.driver.quit()
+
+if __name__ == "__main__":
+    load_dotenv()
+    email = os.getenv("LINKEDIN_EMAIL")
+    password = os.getenv("LINKEDIN_PASSWORD")
+    
+    # Example usage
+    scraper = LinkedInJDScraper(email, password)
+    scraper.login()
+    job_urls = [
+        "https://www.linkedin.com/jobs/view/4123644034", # Add your LinkedIn job ID only here
+    ]
+    job_descriptions = scraper.scrape_job_descriptions(job_urls)
+    print(job_descriptions)
+    scraper.close()

system_prompt.py

@@ -0,0 +1,12 @@
+system_prompt = """
+You are a career assistant specialized in crafting professional and personalized cover letters. 
+Your goal is to create compelling, tailored cover letters that align with the job description. 
+Each cover letter should emphasize the user’s qualifications, skills, and experiences while maintaining a professional tone and structure. 
+Ensure the letter adheres to the following format:
+
+1. **Introduction**: A brief and enthusiastic introduction expressing interest in the role and organization.
+2. **Body**: Highlight relevant skills, experiences, and achievements that align with the job description. Use specific examples when possible.
+3. **Closing**: Reiterate enthusiasm for the role, express willingness to contribute to the organization, and include a polite call to action.
+
+Maintain clarity, professionalism, and conciseness while tailoring the letter. Don't add anything like as advertised.
+"""

user_prompt.py

@@ -0,0 +1,16 @@
+def get_cl_user_prompt_with_scraped_jd(job_url, scraper, resume_skills):
+    # Scrape job description
+    description = scraper.scrape_job_descriptions([job_url]).get(job_url)
+
+    # Construct the prompt
+    user_prompt = "You are tasked with creating a professional and tailored Cover Letter for a job application.\n"
+    user_prompt += "Here is a list of skills and experiences from the candidate's resume:\n"
+    user_prompt += f"{resume_skills}\n\n"
+    user_prompt += "Here is the job description for the position they are applying for:\n"
+    user_prompt += f"{description}\n\n"
+    user_prompt += (
+        "Using the skills from the candidate's resume, craft a CL that highlights their most relevant qualifications "
+        "and experiences for this job making use of job description. "
+        "Ensure the CV follows a professional format and aligns with the role requirements. Present the CV in markdown format.\n"
+    )
+    return user_prompt