Job Application Tracker

 import tkinter as tk

from tkinter import ttk, messagebox

import sqlite3

import pandas as pd

import smtplib

# Database Setup

conn = sqlite3.connect("job_tracker.db")

cursor = conn.cursor()

cursor.execute("""

    CREATE TABLE IF NOT EXISTS jobs (

        id INTEGER PRIMARY KEY AUTOINCREMENT,

        company TEXT,

        role TEXT,

        date_applied TEXT,

        status TEXT

    )

""")

conn.commit()

# GUI Application

class JobTrackerApp:

    def __init__(self, root):

        self.root = root

        self.root.title("Job Application Tracker")

        self.root.geometry("600x400")

        # Labels

        ttk.Label(root, text="Company:").grid(row=0, column=0)

        ttk.Label(root, text="Role:").grid(row=1, column=0)

        ttk.Label(root, text="Date Applied:").grid(row=2, column=0)

        ttk.Label(root, text="Status:").grid(row=3, column=0)

        # Entry Fields

        self.company_entry = ttk.Entry(root)

        self.role_entry = ttk.Entry(root)

        self.date_entry = ttk.Entry(root)

        self.status_combo = ttk.Combobox(root, values=["Pending", "Interview", "Rejected", "Hired"])

        

        self.company_entry.grid(row=0, column=1)

        self.role_entry.grid(row=1, column=1)

        self.date_entry.grid(row=2, column=1)

        self.status_combo.grid(row=3, column=1)

        # Buttons

        ttk.Button(root, text="Add Job", command=self.add_job).grid(row=4, column=0)

        ttk.Button(root, text="Show Jobs", command=self.show_jobs).grid(row=4, column=1)

        ttk.Button(root, text="Export to CSV", command=self.export_csv).grid(row=5, column=0)

        ttk.Button(root, text="Send Follow-up", command=self.send_followup).grid(row=5, column=1)

    def add_job(self):

        company = self.company_entry.get()

        role = self.role_entry.get()

        date = self.date_entry.get()

        status = self.status_combo.get()

        if not company or not role or not date or not status:

            messagebox.showerror("Error", "All fields are required!")

            return

        

        cursor.execute("INSERT INTO jobs (company, role, date_applied, status) VALUES (?, ?, ?, ?)", 

                       (company, role, date, status))

        conn.commit()

        messagebox.showinfo("Success", "Job Application Added!")

    def show_jobs(self):

        jobs_window = tk.Toplevel(self.root)

        jobs_window.title("Job Applications")

        tree = ttk.Treeview(jobs_window, columns=("ID", "Company", "Role", "Date", "Status"), show="headings")

        tree.heading("ID", text="ID")

        tree.heading("Company", text="Company")

        tree.heading("Role", text="Role")

        tree.heading("Date", text="Date Applied")

        tree.heading("Status", text="Status")

        tree.pack(fill="both", expand=True)

        cursor.execute("SELECT * FROM jobs")

        for row in cursor.fetchall():

            tree.insert("", "end", values=row)

    def export_csv(self):

        cursor.execute("SELECT * FROM jobs")

        data = cursor.fetchall()

        df = pd.DataFrame(data, columns=["ID", "Company", "Role", "Date Applied", "Status"])

        df.to_csv("job_applications.csv", index=False)

        messagebox.showinfo("Exported", "Job Applications saved as CSV!")

    def send_followup(self):

        email = "your-email@gmail.com"  # Change to your email

        password = "your-password"  # Use App Password for security

        cursor.execute("SELECT company, role FROM jobs WHERE status='Pending'")

        pending_jobs = cursor.fetchall()

        if not pending_jobs:

            messagebox.showinfo("No Follow-ups", "No pending applications to follow up on.")

            return

        

        msg = "Subject: Follow-up on Job Applications\n\n"

        msg += "Here are your pending job applications:\n"

        for company, role in pending_jobs:

            msg += f"- {role} at {company}\n"

        try:

            server = smtplib.SMTP("smtp.gmail.com", 587)

            server.starttls()

            server.login(email, password)

            server.sendmail(email, email, msg)

            server.quit()

            messagebox.showinfo("Email Sent", "Follow-up email sent successfully!")

        except Exception as e:

            messagebox.showerror("Error", f"Failed to send email: {e}")

# Run App

root = tk.Tk()

app = JobTrackerApp(root)

root.mainloop()

Automated Email Responder

 import imaplib

import smtplib

import email

from email.mime.text import MIMEText

import openai

# Gmail Credentials

EMAIL_USER = "your_email@gmail.com"

EMAIL_PASS = "your_app_password"

# OpenAI API Key (Optional)

OPENAI_API_KEY = "your_openai_api_key"

openai.api_key = OPENAI_API_KEY

# Connect to Gmail Inbox

def check_inbox():

    mail = imaplib.IMAP4_SSL("imap.gmail.com")

    mail.login(EMAIL_USER, EMAIL_PASS)

    mail.select("inbox")

    _, messages = mail.search(None, "UNSEEN")

    email_ids = messages[0].split()

    for email_id in email_ids:

        _, msg_data = mail.fetch(email_id, "(RFC822)")

        for response_part in msg_data:

            if isinstance(response_part, tuple):

                msg = email.message_from_bytes(response_part[1])

                sender = msg["From"]

                subject = msg["Subject"]

                body = extract_body(msg)

                print(f"New Email from: {sender}")

                print(f"Subject: {subject}")

                print(f"Body: {body}")

                reply_message = generate_reply(body)

                send_email(sender, reply_message)

    mail.logout()

# Extract Email Body

def extract_body(msg):

    if msg.is_multipart():

        for part in msg.walk():

            if part.get_content_type() == "text/plain":

                return part.get_payload(decode=True).decode()

    return msg.get_payload(decode=True).decode()

# Generate AI-Based Response (Optional)

def generate_reply(user_query):

    prompt = f"Reply professionally to this email: {user_query}"

    response = openai.ChatCompletion.create(

        model="gpt-3.5-turbo",

        messages=[{"role": "system", "content": "You are a professional email assistant."},

                  {"role": "user", "content": prompt}]

    )

    return response["choices"][0]["message"]["content"]

# Send Email Response

def send_email(to_email, message):

    smtp_server = smtplib.SMTP_SSL("smtp.gmail.com", 465)

    smtp_server.login(EMAIL_USER, EMAIL_PASS)

    msg = MIMEText(message)

    msg["Subject"] = "Re: Your Inquiry"

    msg["From"] = EMAIL_USER

    msg["To"] = to_email

    smtp_server.sendmail(EMAIL_USER, to_email, msg.as_string())

    smtp_server.quit()

    print(f"Auto-reply sent to {to_email}")

# Run the Email Bot

if __name__ == "__main__":

    check_inbox()

YouTube Video Summarizer

 pip install youtube-transcript-api nltk sumy

import tkinter as tk

from tkinter import messagebox

from youtube_transcript_api import YouTubeTranscriptApi

from sumy.parsers.plaintext import PlaintextParser

from sumy.nlp.tokenizers import Tokenizer

from sumy.summarizers.lsa import LsaSummarizer

# Function to extract video ID from URL

def extract_video_id(url):

    if "youtube.com/watch?v=" in url:

        return url.split("v=")[1].split("&")[0]

    elif "youtu.be/" in url:

        return url.split("youtu.be/")[1].split("?")[0]

    else:

        return None

# Function to fetch transcript

def get_transcript(video_url):

    video_id = extract_video_id(video_url)

    if not video_id:

        messagebox.showerror("Error", "Invalid YouTube URL")

        return None

    try:

        transcript = YouTubeTranscriptApi.get_transcript(video_id)

        full_text = " ".join([entry["text"] for entry in transcript])

        return full_text

    except Exception as e:

        messagebox.showerror("Error", f"Could not fetch transcript: {str(e)}")

        return None

# Function to summarize text

def summarize_text(text, num_sentences=3):

    parser = PlaintextParser.from_string(text, Tokenizer("english"))

    summarizer = LsaSummarizer()

    summary = summarizer(parser.document, num_sentences)

    return " ".join(str(sentence) for sentence in summary)

# Function to fetch and summarize

def summarize_video():

    video_url = url_entry.get()

    transcript = get_transcript(video_url)

    

    if transcript:

        summary = summarize_text(transcript)

        output_text.delete("1.0", tk.END)

        output_text.insert(tk.END, summary)

# GUI

root = tk.Tk()

root.title("YouTube Video Summarizer")

tk.Label(root, text="Enter YouTube Video URL:").pack()

url_entry = tk.Entry(root, width=50)

url_entry.pack()

tk.Button(root, text="Summarize", command=summarize_video).pack()

output_text = tk.Text(root, height=10, width=60)

output_text.pack()

root.mainloop()

Automated Screenshot Tool

 pip install pyautogui

import pyautogui

import time

import os

import tkinter as tk

from tkinter import messagebox

# Folder to save screenshots

screenshot_folder = "screenshots"

if not os.path.exists(screenshot_folder):

    os.makedirs(screenshot_folder)

# Function to take a screenshot

def take_screenshot():

    timestamp = time.strftime("%Y-%m-%d_%H-%M-%S")

    filename = os.path.join(screenshot_folder, f"screenshot_{timestamp}.png")

    screenshot = pyautogui.screenshot()

    screenshot.save(filename)

    print(f"✅ Screenshot saved: {filename}")

# Function to start auto screenshots

def start_screenshot():

    try:

        interval = int(entry.get())

        messagebox.showinfo("Started", f"Taking screenshots every {interval} seconds.")

        

        while True:

            take_screenshot()

            time.sleep(interval)

    except ValueError:

        messagebox.showerror("Error", "Please enter a valid number.")

# GUI with Tkinter

root = tk.Tk()

root.title("Automated Screenshot Tool")

tk.Label(root, text="Enter Screenshot Interval (seconds):").pack()

entry = tk.Entry(root)

entry.pack()

tk.Button(root, text="Start Screenshot Capture", command=start_screenshot).pack()

tk.Button(root, text="Exit", command=root.quit).pack()

root.mainloop()

Invoice Generator

 pip install reportlab

from reportlab.lib.pagesizes import letter

from reportlab.pdfgen import canvas

def generate_invoice(client_name, items, tax_rate=0.05, filename="invoice.pdf"):

    c = canvas.Canvas(filename, pagesize=letter)

    width, height = letter

    # Title

    c.setFont("Helvetica-Bold", 16)

    c.drawString(50, height - 50, "INVOICE")

    # Client Details

    c.setFont("Helvetica", 12)

    c.drawString(50, height - 80, f"Client: {client_name}")

    # Table Headers

    c.setFont("Helvetica-Bold", 12)

    c.drawString(50, height - 120, "Item")

    c.drawString(250, height - 120, "Quantity")

    c.drawString(350, height - 120, "Price")

    c.drawString(450, height - 120, "Total")

    # Invoice Items

    c.setFont("Helvetica", 12)

    y_position = height - 140

    total_cost = 0

    for item, details in items.items():

        quantity, price = details

        total = quantity * price

        total_cost += total

        c.drawString(50, y_position, item)

        c.drawString(250, y_position, str(quantity))

        c.drawString(350, y_position, f"${price:.2f}")

        c.drawString(450, y_position, f"${total:.2f}")

        y_position -= 20

    # Tax and Total Calculation

    tax_amount = total_cost * tax_rate

    grand_total = total_cost + tax_amount

    c.setFont("Helvetica-Bold", 12)

    c.drawString(350, y_position - 20, "Subtotal:")

    c.drawString(450, y_position - 20, f"${total_cost:.2f}")

    c.drawString(350, y_position - 40, f"Tax ({tax_rate * 100}%):")

    c.drawString(450, y_position - 40, f"${tax_amount:.2f}")

    c.drawString(350, y_position - 60, "Grand Total:")

    c.drawString(450, y_position - 60, f"${grand_total:.2f}")

    # Save PDF

    c.save()

    print(f"✅ Invoice saved as {filename}")