Image Duplicate Finder (Hash-Based)

import os

import tkinter as tk

from tkinter import filedialog, ttk, messagebox

from PIL import Image, ImageTk

import imagehash

class ImageDuplicateFinder:

    def __init__(self, root):

        self.root = root

        self.root.title("Image Duplicate Finder (Hash-Based)")

        self.root.geometry("900x600")

        self.image_hash_map = {}

        self.duplicates = []

        self.setup_ui()

    # ---------------------------------------------------------

    def setup_ui(self):

        top_frame = tk.Frame(self.root)

        top_frame.pack(fill=tk.X, pady=10)

        tk.Button(top_frame, text="Select Folder", command=self.select_folder).pack(side=tk.LEFT, padx=10)

        tk.Button(top_frame, text="Scan for Duplicates", command=self.scan_duplicates).pack(side=tk.LEFT, padx=10)

        self.result_tree = ttk.Treeview(self.root, columns=("img1", "img2"), show="headings")

        self.result_tree.heading("img1", text="Image 1")

        self.result_tree.heading("img2", text="Duplicate Image")

        self.result_tree.pack(fill="both", expand=True, pady=10)

        self.result_tree.bind("<Double-1>", self.show_preview)

    # ---------------------------------------------------------

    def select_folder(self):

        self.folder_path = filedialog.askdirectory()

        if self.folder_path:

            messagebox.showinfo("Selected Folder", self.folder_path)

    # ---------------------------------------------------------

    def scan_duplicates(self):

        if not hasattr(self, "folder_path"):

            messagebox.showerror("Error", "Please select a folder first!")

            return

        self.image_hash_map = {}

        self.duplicates = []

        self.result_tree.delete(*self.result_tree.get_children())

        supported_ext = (".jpg", ".jpeg", ".png", ".bmp")

        for filename in os.listdir(self.folder_path):

            if filename.lower().endswith(supported_ext):

                full_path = os.path.join(self.folder_path, filename)

                try:

                    img = Image.open(full_path)

                    img_hash = imagehash.average_hash(img)

                    if img_hash in self.image_hash_map:

                        self.duplicates.append((self.image_hash_map[img_hash], full_path))

                    else:

                        self.image_hash_map[img_hash] = full_path

                except Exception as e:

                    print("Error loading:", filename, e)

        # Show results in table

        for dup in self.duplicates:

            self.result_tree.insert("", tk.END, values=dup)

        if not self.duplicates:

            messagebox.showinfo("Result", "No duplicates found!")

        else:

            messagebox.showinfo("Result", f"Found {len(self.duplicates)} duplicate pairs.")

    # ---------------------------------------------------------

    def show_preview(self, event):

        selected = self.result_tree.focus()

        if not selected:

            return

        img1_path, img2_path = self.result_tree.item(selected, "values")

        self.preview_window(img1_path, img2_path)

    # ---------------------------------------------------------

    def preview_window(self, img1_path, img2_path):

        win = tk.Toplevel(self.root)

        win.title("Duplicate Image Preview")

        win.geometry("850x450")

        tk.Label(win, text=f"Image 1: {os.path.basename(img1_path)}", font=("Arial", 10)).pack(pady=5)

        tk.Label(win, text=f"Image 2: {os.path.basename(img2_path)}", font=("Arial", 10)).pack(pady=5)

        frame = tk.Frame(win)

        frame.pack(expand=True)

        # Load images

        img1 = Image.open(img1_path).resize((350, 350))

        img2 = Image.open(img2_path).resize((350, 350))

        img1_tk = ImageTk.PhotoImage(img1)

        img2_tk = ImageTk.PhotoImage(img2)

        left_label = tk.Label(frame, image=img1_tk)

        left_label.image = img1_tk

        left_label.pack(side=tk.LEFT, padx=10)

        right_label = tk.Label(frame, image=img2_tk)

        right_label.image = img2_tk

        right_label.pack(side=tk.RIGHT, padx=10)

# ---------------------------------------------------------

# RUN APP

# ---------------------------------------------------------

root = tk.Tk()

app = ImageDuplicateFinder(root)

root.mainloop()

 

Smart PDF Page Extractor

import fitz  # PyMuPDF

import tkinter as tk

from tkinter import filedialog, messagebox, ttk

from PIL import Image, ImageTk

class PDFExtractorApp:

    def __init__(self, root):

        self.root = root

        self.root.title("Smart PDF Page Extractor")

        self.root.geometry("900x600")

        self.pdf_doc = None

        self.page_images = []

        self.selected_pages = []

        self.create_ui()

    # -------------------------------------------------------------

    # UI SETUP

    # -------------------------------------------------------------

    def create_ui(self):

        top_frame = tk.Frame(self.root)

        top_frame.pack(fill=tk.X, pady=10)

        tk.Button(top_frame, text="Open PDF", command=self.open_pdf).pack(side=tk.LEFT, padx=10)

        tk.Button(top_frame, text="Extract Selected", command=self.extract_pages).pack(side=tk.LEFT, padx=10)

        tk.Button(top_frame, text="Save New PDF", command=self.save_new_pdf).pack(side=tk.LEFT, padx=10)

        self.canvas = tk.Canvas(self.root, bg="white")

        self.scroll_y = tk.Scrollbar(self.root, orient="vertical", command=self.canvas.yview)

        self.canvas.configure(yscrollcommand=self.scroll_y.set)

        self.frame = tk.Frame(self.canvas)

        self.canvas.create_window((0, 0), window=self.frame, anchor="nw")

        self.canvas.pack(side=tk.LEFT, fill="both", expand=True)

        self.scroll_y.pack(side=tk.RIGHT, fill="y")

        self.frame.bind("<Configure>", lambda e: self.canvas.configure(scrollregion=self.canvas.bbox("all")))

    # -------------------------------------------------------------

    # OPEN PDF

    # -------------------------------------------------------------

    def open_pdf(self):

        filepath = filedialog.askopenfilename(

            filetypes=[("PDF Files", "*.pdf")],

            title="Choose a PDF"

        )

        if not filepath:

            return

        try:

            self.pdf_doc = fitz.open(filepath)

            self.load_pages()

        except Exception as e:

            messagebox.showerror("Error", f"Failed to open PDF:\n{e}")

    # -------------------------------------------------------------

    # LOAD AND DISPLAY PAGE THUMBNAILS

    # -------------------------------------------------------------

    def load_pages(self):

        for widget in self.frame.winfo_children():

            widget.destroy()

        self.selected_pages = []

        self.page_images = []

        for page_num in range(len(self.pdf_doc)):

            page = self.pdf_doc.load_page(page_num)

            pix = page.get_pixmap(matrix=fitz.Matrix(0.3, 0.3))  # thumbnail scale

            image = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)

            img_tk = ImageTk.PhotoImage(image)

            self.page_images.append(img_tk)

            page_frame = tk.Frame(self.frame, bd=2, relief="groove")

            page_frame.pack(padx=10, pady=10, anchor="w")

            label = tk.Label(page_frame, image=img_tk)

            label.pack()

            tk.Label(page_frame, text=f"Page {page_num + 1}", font=("Arial", 12, "bold")).pack()

            btn = tk.Button(

                page_frame,

                text="Select",

                command=lambda n=page_num: self.toggle_page(n)

            )

            btn.pack(pady=5)

    # -------------------------------------------------------------

    # SELECT / UNSELECT PAGE

    # -------------------------------------------------------------

    def toggle_page(self, page_num):

        if page_num in self.selected_pages:

            self.selected_pages.remove(page_num)

            messagebox.showinfo("Page Unselected", f"Page {page_num + 1} removed.")

        else:

            self.selected_pages.append(page_num)

            messagebox.showinfo("Page Selected", f"Page {page_num + 1} selected.")

    # -------------------------------------------------------------

    # EXTRACT SELECTED PAGES

    # -------------------------------------------------------------

    def extract_pages(self):

        if not self.selected_pages:

            messagebox.showerror("Error", "No pages selected!")

            return

        self.selected_pages.sort()

        messagebox.showinfo("Selected Pages", f"Extracting pages: {[p+1 for p in self.selected_pages]}")

    # -------------------------------------------------------------

    # SAVE NEW PDF WITH SELECTED PAGES

    # -------------------------------------------------------------

    def save_new_pdf(self):

        if not self.selected_pages:

            messagebox.showerror("Error", "Select pages before saving!")

            return

        output_path = filedialog.asksaveasfilename(

            defaultextension=".pdf",

            filetypes=[("PDF Files", "*.pdf")],

            title="Save Extracted PDF"

        )

        if not output_path:

            return

        try:

            new_pdf = fitz.open()

            for page_num in self.selected_pages:

                new_pdf.insert_pdf(self.pdf_doc, from_page=page_num, to_page=page_num)

            new_pdf.save(output_path)

            new_pdf.close()

            messagebox.showinfo("Success", "New PDF saved successfully!")

        except Exception as e:

            messagebox.showerror("Error", f"Failed to save PDF:\n{e}")

# -------------------------------------------------------------

# RUN APP

# -------------------------------------------------------------

root = tk.Tk()

app = PDFExtractorApp(root)

root.mainloop()

Offline Travel Expense Splitter App

import tkinter as tk

from tkinter import ttk, messagebox

import sqlite3

from fpdf import FPDF

# ---------------------------------------------------

# DATABASE SETUP

# ---------------------------------------------------

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

cursor = conn.cursor()

cursor.execute("""

CREATE TABLE IF NOT EXISTS members (

    id INTEGER PRIMARY KEY AUTOINCREMENT,

    name TEXT NOT NULL

)

""")

cursor.execute("""

CREATE TABLE IF NOT EXISTS expenses (

    id INTEGER PRIMARY KEY AUTOINCREMENT,

    member_id INTEGER,

    description TEXT,

    amount REAL,

    FOREIGN KEY(member_id) REFERENCES members(id)

)

""")

conn.commit()

# ---------------------------------------------------

# MAIN APPLICATION

# ---------------------------------------------------

class TravelExpenseApp:

    def __init__(self, root):

        self.root = root

        self.root.title("Travel Expense Splitter")

        self.root.geometry("600x500")

        self.create_ui()

    # ------------------------ UI ------------------------

    def create_ui(self):

        tab_control = ttk.Notebook(self.root)

        self.tab_members = ttk.Frame(tab_control)

        self.tab_expenses = ttk.Frame(tab_control)

        self.tab_summary = ttk.Frame(tab_control)

        tab_control.add(self.tab_members, text="Members")

        tab_control.add(self.tab_expenses, text="Expenses")

        tab_control.add(self.tab_summary, text="Summary")

        tab_control.pack(expand=1, fill="both")

        self.setup_members_tab()

        self.setup_expenses_tab()

        self.setup_summary_tab()

    # ------------------------ MEMBERS TAB ------------------------

    def setup_members_tab(self):

        tk.Label(self.tab_members, text="Add Member", font=("Arial", 14)).pack(pady=10)

        self.member_entry = tk.Entry(self.tab_members, font=("Arial", 12))

        self.member_entry.pack(pady=5)

        tk.Button(self.tab_members, text="Add Member", command=self.add_member).pack(pady=10)

        self.members_list = tk.Listbox(self.tab_members, width=40, height=10)

        self.members_list.pack(pady=10)

        self.load_members()

    def add_member(self):

        name = self.member_entry.get()

        if not name:

            messagebox.showerror("Error", "Please enter a name!")

            return

        cursor.execute("INSERT INTO members (name) VALUES (?)", (name,))

        conn.commit()

        self.member_entry.delete(0, tk.END)

        self.load_members()

    def load_members(self):

        self.members_list.delete(0, tk.END)

        cursor.execute("SELECT name FROM members")

        for row in cursor.fetchall():

            self.members_list.insert(tk.END, row[0])

    # ------------------------ EXPENSE TAB ------------------------

    def setup_expenses_tab(self):

        tk.Label(self.tab_expenses, text="Add Expense", font=("Arial", 14)).pack(pady=10)

        tk.Label(self.tab_expenses, text="Select Member:").pack()

        self.member_dropdown = ttk.Combobox(self.tab_expenses, state="readonly")

        self.member_dropdown.pack(pady=5)

        self.load_member_dropdown()

        tk.Label(self.tab_expenses, text="Description:").pack()

        self.desc_entry = tk.Entry(self.tab_expenses, font=("Arial", 12))

        self.desc_entry.pack(pady=5)

        tk.Label(self.tab_expenses, text="Amount:").pack()

        self.amount_entry = tk.Entry(self.tab_expenses, font=("Arial", 12))

        self.amount_entry.pack(pady=5)

        tk.Button(self.tab_expenses, text="Add Expense", command=self.add_expense).pack(pady=10)

        self.expense_tree = ttk.Treeview(self.tab_expenses, columns=("member", "desc", "amount"), show="headings")

        self.expense_tree.heading("member", text="Member")

        self.expense_tree.heading("desc", text="Description")

        self.expense_tree.heading("amount", text="Amount")

        self.expense_tree.pack(fill="both", expand=True)

        self.load_expenses()

    def load_member_dropdown(self):

        cursor.execute("SELECT name FROM members")

        members = [row[0] for row in cursor.fetchall()]

        self.member_dropdown["values"] = members

    def add_expense(self):

        member = self.member_dropdown.get()

        desc = self.desc_entry.get()

        amount = self.amount_entry.get()

        if not member or not desc or not amount:

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

            return

        try:

            amount = float(amount)

        except:

            messagebox.showerror("Error", "Amount must be a number!")

            return

        cursor.execute("SELECT id FROM members WHERE name=?", (member,))

        member_id = cursor.fetchone()[0]

        cursor.execute("INSERT INTO expenses (member_id, description, amount) VALUES (?, ?, ?)",

                       (member_id, desc, amount))

        conn.commit()

        self.desc_entry.delete(0, tk.END)

        self.amount_entry.delete(0, tk.END)

        self.load_expenses()

    def load_expenses(self):

        for i in self.expense_tree.get_children():

            self.expense_tree.delete(i)

        cursor.execute("""

            SELECT members.name, expenses.description, expenses.amount

            FROM expenses

            JOIN members ON expenses.member_id = members.id

        """)

        for row in cursor.fetchall():

            self.expense_tree.insert("", tk.END, values=row)

    # ------------------------ SUMMARY TAB ------------------------

    def setup_summary_tab(self):

        tk.Label(self.tab_summary, text="Expense Summary", font=("Arial", 14)).pack(pady=10)

        tk.Button(self.tab_summary, text="Calculate Summary", command=self.calculate_summary).pack(pady=10)

        tk.Button(self.tab_summary, text="Export PDF", command=self.export_pdf).pack(pady=10)

        self.summary_box = tk.Text(self.tab_summary, height=20, width=70)

        self.summary_box.pack()

    def calculate_summary(self):

        cursor.execute("SELECT COUNT(*) FROM members")

        num_members = cursor.fetchone()[0]

        cursor.execute("SELECT SUM(amount) FROM expenses")

        total_expense = cursor.fetchone()[0] or 0

        split_amount = total_expense / num_members if num_members > 0 else 0

        self.summary_box.delete(1.0, tk.END)

        self.summary_box.insert(tk.END, f"Total Expense: ₹{total_expense:.2f}\n")

        self.summary_box.insert(tk.END, f"Each Person Should Pay: ₹{split_amount:.2f}\n\n")

        cursor.execute("""

            SELECT members.name, SUM(expenses.amount)

            FROM members

            LEFT JOIN expenses ON members.id = expenses.member_id

            GROUP BY members.name

        """)

        for name, paid in cursor.fetchall():

            paid = paid or 0

            diff = paid - split_amount

            status = "owes" if diff < 0 else "gets back"

            self.summary_box.insert(tk.END, f"{name}: Paid ₹{paid:.2f} → {status} ₹{abs(diff):.2f}\n")

    # ------------------------ PDF EXPORT ------------------------

    def export_pdf(self):

        pdf = FPDF()

        pdf.add_page()

        pdf.set_font("Arial", size=12)

        pdf.cell(200, 10, "Travel Expense Summary", ln=True, align="C")

        pdf.ln(10)

        summary_text = self.summary_box.get(1.0, tk.END).split("\n")

        for line in summary_text:

            pdf.cell(0, 10, txt=line, ln=True)

        pdf.output("Travel_Expense_Summary.pdf")

        messagebox.showinfo("Success", "PDF Exported Successfully!")

# ------------------------ RUN APP ------------------------

root = tk.Tk()

app = TravelExpenseApp(root)

root.mainloop()

AI-Focused Book Summarizer & Chapter Highlighter

import fitz  # PyMuPDF

import nltk

import re

from transformers import pipeline

# Load HuggingFace summarizer

summarizer = pipeline(

    "summarization", 

    model="facebook/bart-large-cnn"

)

# ----------------------------------------

# 1. Extract text from PDF

# ----------------------------------------

def extract_pdf_text(pdf_path):

    doc = fitz.open(pdf_path)

    full_text = ""

    for page in doc:

        full_text += page.get_text()

    return full_text

# ----------------------------------------

# 2. Split text into chapters

#    Uses patterns like:

#     - Chapter 1

#     - CHAPTER I

#     - CHAPTER ONE

# ----------------------------------------

def split_into_chapters(text):

    chapter_pattern = r"(chapter\s+\d+|chapter\s+[ivxlcdm]+|chapter\s+\w+)"

    found = re.split(chapter_pattern, text, flags=re.IGNORECASE)

    chapters = []

    for i in range(1, len(found), 2):

        title = found[i].strip()

        content = found[i + 1].strip()

        chapters.append((title, content))

    # If no chapters are detected → return full book as one chapter

    if not chapters:

        return [("Full Book", text)]

    return chapters

# ----------------------------------------

# 3. Summarize long text in safe chunks

# ----------------------------------------

def summarize_long_text(text, max_chunk=1500):

    nltk.download("punkt", quiet=True)

    sentences = nltk.sent_tokenize(text)

    chunks = []

    current_chunk = ""

    for sentence in sentences:

        if len(current_chunk) + len(sentence) <= max_chunk:

            current_chunk += " " + sentence

        else:

            chunks.append(current_chunk)

            current_chunk = sentence

    if current_chunk:

        chunks.append(current_chunk)

    # Summarize each chunk

    summaries = []

    for chunk in chunks:

        summary = summarizer(chunk, max_length=130, min_length=30, do_sample=False)[0]["summary_text"]

        summaries.append(summary)

    # Join all summaries

    return "\n".join(summaries)

# ----------------------------------------

# 4. Generate key points

# ----------------------------------------

def generate_key_points(summary):

    sentences = nltk.sent_tokenize(summary)

    key_points = sentences[:5]   # Top 5 key ideas

    return ["• " + s for s in key_points]

# ----------------------------------------

# 5. End-to-End Pipeline

# ----------------------------------------

def summarize_book(pdf_path):

    print("\n📘 Extracting PDF text...")

    text = extract_pdf_text(pdf_path)

    print("✂ Splitting into chapters...")

    chapters = split_into_chapters(text)

    results = []

    for idx, (title, content) in enumerate(chapters, start=1):

        print(f"\n📝 Summarizing {title}...")

        summary = summarize_long_text(content)

        key_points = generate_key_points(summary)

        results.append({

            "chapter_title": title,

            "summary": summary,

            "key_points": key_points

        })

    return results

# ----------------------------------------

# 6. Print Results Nicely

# ----------------------------------------

def display_results(results):

    print("\n============================")

    print("📚 BOOK SUMMARY REPORT")

    print("============================\n")

    for item in results:

        print(f"\n===== {item['chapter_title']} =====\n")

        print("SUMMARY:\n")

        print(item["summary"])

        print("\nKEY POINTS:")

        for p in item["key_points"]:

            print(p)

        print("\n---------------------------")

# ----------------------------------------

# RUN

# ----------------------------------------

if __name__ == "__main__":

    pdf_path = input("Enter PDF file path: ").strip()

    results = summarize_book(pdf_path)

    display_results(results)

    print("\n✔ Done! All chapters processed.")

Backup Scheduler

import schedule

import shutil

import time

import os

from datetime import datetime

# ------------------------------

# CONFIGURATION

# ------------------------------

SOURCE_FOLDER = r"E:\MyData"           # Folder to back up

DESTINATION_FOLDER = r"F:\Backups"     # External drive / backup location

BACKUP_FREQUENCY = "hourly"            # options: hourly, daily, custom

# ------------------------------

# Create destination folder if missing

# ------------------------------

def ensure_destination():

    if not os.path.exists(DESTINATION_FOLDER):

        os.makedirs(DESTINATION_FOLDER)

        print(f"[INFO] Created backup directory: {DESTINATION_FOLDER}")

# ------------------------------

# Perform Backup

# ------------------------------

def perform_backup():

    ensure_destination()

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

    backup_path = os.path.join(DESTINATION_FOLDER, f"backup_{timestamp}")

    try:

        print(f"[START] Backing up '{SOURCE_FOLDER}' → '{backup_path}'")

        shutil.copytree(SOURCE_FOLDER, backup_path)

        print(f"[DONE] Backup completed successfully! ✔️\n")

    except Exception as e:

        print(f"[ERROR] Backup failed: {e}\n")

# ------------------------------

# Schedule Backup

# ------------------------------

def schedule_backups():

    if BACKUP_FREQUENCY == "hourly":

        schedule.every().hour.do(perform_backup)

        print("[SCHEDULER] Backup scheduled: Every hour.")

    

    elif BACKUP_FREQUENCY == "daily":

        schedule.every().day.at("00:00").do(perform_backup)

        print("[SCHEDULER] Backup scheduled: Every day at 12:00 AM.")

    

    else:

        # custom frequency example: every 10 minutes

        schedule.every(10).minutes.do(perform_backup)

        print("[SCHEDULER] Backup scheduled: Every 10 minutes (custom).")

# ------------------------------

# MAIN LOOP

# ------------------------------

def main():

    print("===== Python Backup Scheduler Started =====")

    print(f"Source Folder:      {SOURCE_FOLDER}")

    print(f"Destination Folder: {DESTINATION_FOLDER}")

    print("=================================================\n")

    schedule_backups()

    # Continuous loop

    while True:

        schedule.run_pending()

        time.sleep(1)

if __name__ == "__main__":

    main()

Offline Dictionary App

import tkinter as tk

from tkinter import messagebox

import sqlite3

import pyttsx3

# -----------------------------

# Database Setup

# -----------------------------

def init_db():

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

    cur = conn.cursor()

    cur.execute("""

        CREATE TABLE IF NOT EXISTS words (

            word TEXT PRIMARY KEY,

            meaning TEXT

        );

    """)

    cur.execute("""

        CREATE TABLE IF NOT EXISTS favorites (

            word TEXT PRIMARY KEY

        );

    """)

    conn.commit()

    conn.close()

# -----------------------------

# Insert sample words (optional)

# -----------------------------

def insert_sample_words():

    sample_data = {

        "python": "A high-level programming language used for general-purpose programming.",

        "algorithm": "A step-by-step procedure for solving a problem or performing a task.",

        "variable": "A storage location paired with a name used to store values.",

        "database": "A structured collection of data stored electronically.",

    }

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

    cur = conn.cursor()

    

    for word, meaning in sample_data.items():

        cur.execute("INSERT OR IGNORE INTO words VALUES (?, ?)", (word, meaning))

    conn.commit()

    conn.close()

# -----------------------------

# Text-to-Speech

# -----------------------------

engine = pyttsx3.init()

def speak_word(word):

    engine.say(word)

    engine.runAndWait()

# -----------------------------

# Dictionary Operations

# -----------------------------

def search_word():

    word = entry_word.get().strip().lower()

    if not word:

        messagebox.showerror("Error", "Please enter a word to search.")

        return

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

    cur = conn.cursor()

    cur.execute("SELECT meaning FROM words WHERE word=?", (word,))

    result = cur.fetchone()

    if result:

        text_meaning.config(state="normal")

        text_meaning.delete(1.0, tk.END)

        text_meaning.insert(tk.END, result[0])

        text_meaning.config(state="disabled")

    else:

        messagebox.showinfo("Not Found", "Word not found in offline dictionary.")

    

    conn.close()

def add_word():

    word = entry_add_word.get().strip().lower()

    meaning = text_add_meaning.get(1.0, tk.END).strip()

    if not word or not meaning:

        messagebox.showerror("Error", "Both word and meaning are required.")

        return

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

    cur = conn.cursor()

    cur.execute("INSERT OR REPLACE INTO words VALUES (?, ?)", (word, meaning))

    conn.commit()

    conn.close()

    messagebox.showinfo("Success", f"'{word}' added to dictionary.")

def add_to_favorites():

    word = entry_word.get().strip().lower()

    if not word:

        messagebox.showerror("Error", "Search a word first before adding to favorites.")

        return

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

    cur = conn.cursor()

    cur.execute("INSERT OR IGNORE INTO favorites VALUES (?)", (word,))

    conn.commit()

    conn.close()

    messagebox.showinfo("Added", f"'{word}' added to favorites!")

def show_favorites():

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

    cur = conn.cursor()

    cur.execute("SELECT word FROM favorites")

    favs = cur.fetchall()

    conn.close()

    fav_list = "\n".join([w[0] for w in favs]) if favs else "No favorites added yet."

    messagebox.showinfo("Favorite Words", fav_list)

# -----------------------------

# GUI Setup

# -----------------------------

root = tk.Tk()

root.title("Offline Dictionary App")

root.geometry("650x500")

root.resizable(False, False)

# Search section

tk.Label(root, text="Enter Word:", font=("Arial", 14)).pack(pady=5)

entry_word = tk.Entry(root, font=("Arial", 14), width=30)

entry_word.pack()

btn_search = tk.Button(root, text="Search", font=("Arial", 12), command=search_word)

btn_search.pack(pady=5)

btn_speak = tk.Button(root, text="🔊 Speak", font=("Arial", 12), command=lambda: speak_word(entry_word.get()))

btn_speak.pack(pady=2)

btn_fav = tk.Button(root, text="⭐ Add to Favorites", font=("Arial", 12), command=add_to_favorites)

btn_fav.pack(pady=2)

# Meaning display

tk.Label(root, text="Meaning:", font=("Arial", 14)).pack()

text_meaning = tk.Text(root, height=6, width=60, font=("Arial", 12), state="disabled")

text_meaning.pack(pady=5)

# Add new word section

tk.Label(root, text="Add New Word:", font=("Arial", 14)).pack(pady=5)

entry_add_word = tk.Entry(root, font=("Arial", 12), width=30)

entry_add_word.pack()

tk.Label(root, text="Meaning:", font=("Arial", 14)).pack()

text_add_meaning = tk.Text(root, height=4, width=60, font=("Arial", 12))

text_add_meaning.pack()

btn_add = tk.Button(root, text="Add Word to Dictionary", font=("Arial", 12), command=add_word)

btn_add.pack(pady=5)

# favorites

btn_show_fav = tk.Button(root, text="📌 Show Favorites", font=("Arial", 12), command=show_favorites)

btn_show_fav.pack(pady=5)

# Run

init_db()

insert_sample_words()

root.mainloop()

Resume ATS Scoring Tool

import fitz  # PyMuPDF

import spacy

import re

import pandas as pd

nlp = spacy.load("en_core_web_sm")

# ---------------------------------------

# Utility: Extract text from PDF or TXT

# ---------------------------------------

def extract_text(file_path):

    if file_path.lower().endswith(".pdf"):

        text = ""

        pdf = fitz.open(file_path)

        for page in pdf:

            text += page.get_text()

        return text

    else:

        # for .txt files

        with open(file_path, "r", encoding="utf-8") as f:

            return f.read()

# ---------------------------------------

# Clean & Normalize Text

# ---------------------------------------

def clean_text(text):

    text = text.lower()

    text = re.sub(r'[^a-zA-Z0-9\s]', ' ', text)

    text = re.sub(r'\s+', ' ', text)

    return text

# ---------------------------------------

# Extract Keywords Using spaCy

# ---------------------------------------

def extract_keywords(text):

    doc = nlp(text)

    keywords = []

    for token in doc:

        # Keep nouns, verbs, adjectives (important for ATS)

        if token.pos_ in ["NOUN", "PROPN", "VERB", "ADJ"]:

            if len(token.text) > 2:

                keywords.append(token.lemma_.lower())

    return list(set(keywords))

# ---------------------------------------

# ATS Scoring Logic

# ---------------------------------------

def calculate_ats_score(resume_text, jd_text):

    resume_clean = clean_text(resume_text)

    jd_clean = clean_text(jd_text)

    resume_keywords = extract_keywords(resume_clean)

    jd_keywords = extract_keywords(jd_clean)

    matched = [kw for kw in jd_keywords if kw in resume_keywords]

    missing = [kw for kw in jd_keywords if kw not in resume_keywords]

    score = (len(matched) / len(jd_keywords)) * 100 if jd_keywords else 0

    return {

        "ats_score": round(score, 2),

        "matched_keywords": matched,

        "missing_keywords": missing,

        "total_keywords": len(jd_keywords)

    }

# ---------------------------------------

# MAIN FUNCTION

# ---------------------------------------

def ats_tool(resume_file, jobdesc_file):

    resume_text = extract_text(resume_file)

    jd_text = extract_text(jobdesc_file)

    result = calculate_ats_score(resume_text, jd_text)

    print("\n ATS SCORING RESULTS")

    print("--------------------------------")

    print(f"ATS Score: {result['ats_score']}%")

    print(f"Total Keywords in Job Description: {result['total_keywords']}")

    print(f"Matched Keywords ({len(result['matched_keywords'])}):")

    print(result["matched_keywords"])

    print("\nMissing Keywords:")

    print(result["missing_keywords"])

    # Export to CSV (optional)

    df = pd.DataFrame({

        "Matched Keywords": pd.Series(result["matched_keywords"]),

        "Missing Keywords": pd.Series(result["missing_keywords"])

    })

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

    print("\n Report saved as ats_report.csv")

# ---------------------------------------

# RUN

# ---------------------------------------

if __name__ == "__main__":

    resume_path = input("Enter Resume File Path (.pdf/.txt): ")

    jd_path = input("Enter Job Description File Path (.pdf/.txt): ")

    ats_tool(resume_path, jd_path)

Command Palette Launcher (VS Code Style)

 """

Command Palette Launcher (VS Code style)

Tech: tkinter, os, keyboard, difflib

Features:

- Ctrl+P to open palette (global using 'keyboard', and also inside Tk window)

- Index files from a folder for quick search

- Fuzzy search using difflib

- Open files (os.startfile on Windows / xdg-open on Linux / open on macOS)

- Add custom commands (open app, shell command)

- Demo includes uploaded file path: /mnt/data/image.png

"""

import os

import sys

import threading

import platform

import subprocess

from pathlib import Path

import tkinter as tk

from tkinter import ttk, filedialog, messagebox

from difflib import get_close_matches

# Optional global hotkey package

try:

    import keyboard  # pip install keyboard

    KEYBOARD_AVAILABLE = True

except Exception:

    KEYBOARD_AVAILABLE = False

# Demo uploaded file path (from your session)

DEMO_FILE = "/mnt/data/image.png"

# ------------------------------

# Utility functions

# ------------------------------

def open_path(path):

    """Open a file or folder using the OS default application."""

    p = str(path)

    if platform.system() == "Windows":

        os.startfile(p)

    elif platform.system() == "Darwin":  # macOS

        subprocess.Popen(["open", p])

    else:  # Linux and others

        subprocess.Popen(["xdg-open", p])

def is_executable_file(path):

    try:

        return os.access(path, os.X_OK) and Path(path).is_file()

    except Exception:

        return False

# ------------------------------

# Indexer

# ------------------------------

class FileIndexer:

    def __init__(self):

        self.items = []  # list of {"title": ..., "path": ..., "type": "file"|"cmd"}

        # preload demo item if exists

        if Path(DEMO_FILE).exists():

            self.add_item(title=Path(DEMO_FILE).name, path=str(DEMO_FILE), typ="file")

    def add_item(self, title, path, typ="file"):

        rec = {"title": title, "path": path, "type": typ}

        self.items.append(rec)

    def index_folder(self, folder, max_files=5000):

        """Recursively index a folder (stop at max_files)."""

        folder = Path(folder)

        count = 0

        for root, dirs, files in os.walk(folder):

            for f in files:

                try:

                    fp = Path(root) / f

                    self.add_item(title=f, path=str(fp), typ="file")

                    count += 1

                    if count >= max_files:

                        return count

                except Exception:

                    continue

        return count

    def add_common_apps(self):

        """Add some common app commands (platform-specific)."""

        sysplat = platform.system()

        apps = []

        if sysplat == "Windows":

            # common Windows apps (paths may vary)

            apps = [

                ("Notepad", "notepad.exe"),

                ("Calculator", "calc.exe"),

                ("Paint", "mspaint.exe"),

            ]

        elif sysplat == "Darwin":

            apps = [

                ("TextEdit", "open -a TextEdit"),

                ("Calculator", "open -a Calculator"),

            ]

        else:  # Linux

            apps = [

                ("Gedit", "gedit"),

                ("Calculator", "gnome-calculator"),

            ]

        for name, cmd in apps:

            self.add_item(title=name, path=cmd, typ="cmd")

    def search(self, query, limit=15):

        """Simple fuzzy search: look for substrings first, then difflib matches."""

        q = query.strip().lower()

        if not q:

            # return top items

            return self.items[:limit]

        # substring matches (higher priority)

        substr_matches = [it for it in self.items if q in it["title"].lower() or q in it["path"].lower()]

        if len(substr_matches) >= limit:

            return substr_matches[:limit]

        # prepare list of titles for difflib

        titles = [it["title"] for it in self.items]

        close = get_close_matches(q, titles, n=limit, cutoff=0.4)

        # map back to records preserving order (titles may repeat)

        close_records = []

        for t in close:

            for it in self.items:

                if it["title"] == t and it not in close_records:

                    close_records.append(it)

                    break

        # combine substring + close matches, ensure uniqueness

        results = []

        seen = set()

        for it in substr_matches + close_records:

            key = (it["title"], it["path"])

            if key not in seen:

                results.append(it)

                seen.add(key)

            if len(results) >= limit:

                break

        return results

# ------------------------------

# GUI

# ------------------------------

class CommandPalette(tk.Toplevel):

    def __init__(self, master, indexer: FileIndexer):

        super().__init__(master)

        self.indexer = indexer

        self.title("Command Palette")

        self.geometry("700x380")

        self.transient(master)

        self.grab_set()  # modal

        self.resizable(False, False)

        # Styling

        self.configure(bg="#2b2b2b")

        # Search box

        self.search_var = tk.StringVar()

        search_entry = ttk.Entry(self, textvariable=self.search_var, font=("Consolas", 14), width=60)

        search_entry.pack(padx=12, pady=(12,6))

        search_entry.focus_set()

        search_entry.bind("<KeyRelease>", self.on_search_key)

        search_entry.bind("<Escape>", lambda e: self.close())

        search_entry.bind("<Return>", lambda e: self.open_selected())

        # Results list

        self.tree = ttk.Treeview(self, columns=("title","path","type"), show="headings", height=12)

        self.tree.heading("title", text="Title")

        self.tree.heading("path", text="Path / Command")

        self.tree.heading("type", text="Type")

        self.tree.column("title", width=250)

        self.tree.column("path", width=350)

        self.tree.column("type", width=80, anchor="center")

        self.tree.pack(padx=12, pady=6, fill="both", expand=True)

        self.tree.bind("<Double-1>", lambda e: self.open_selected())

        self.tree.bind("<Return>", lambda e: self.open_selected())

        # Bottom buttons

        btn_frame = ttk.Frame(self)

        btn_frame.pack(fill="x", padx=12, pady=(0,12))

        ttk.Button(btn_frame, text="Open Folder to Index", command=self.browse_and_index).pack(side="left")

        ttk.Button(btn_frame, text="Add Command", command=self.add_command_dialog).pack(side="left", padx=6)

        ttk.Button(btn_frame, text="Close (Esc)", command=self.close).pack(side="right")

        # initial populate

        self.update_results(self.indexer.items[:50])

    def on_search_key(self, event=None):

        q = self.search_var.get()

        results = self.indexer.search(q, limit=50)

        self.update_results(results)

        # keep the first row selected

        children = self.tree.get_children()

        if children:

            self.tree.selection_set(children[0])

            self.tree.focus(children[0])

    def update_results(self, records):

        # clear

        for r in self.tree.get_children():

            self.tree.delete(r)

        for rec in records:

            self.tree.insert("", "end", values=(rec["title"], rec["path"], rec["type"]))

    def open_selected(self):

        sel = self.tree.selection()

        if not sel:

            return

        vals = self.tree.item(sel[0])["values"]

        title, path, typ = vals

        try:

            if typ == "file":

                open_path(path)

            elif typ == "cmd":

                # if it's a shell command, run it

                # Allow both simple exe names and complex shell commands

                if platform.system() == "Windows":

                    subprocess.Popen(path, shell=True)

                else:

                    subprocess.Popen(path.split(), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)

            else:

                # fallback attempt

                open_path(path)

        except Exception as e:

            messagebox.showerror("Open failed", f"Could not open {path}\n\n{e}")

        finally:

            self.close()

    def browse_and_index(self):

        folder = filedialog.askdirectory()

        if not folder:

            return

        count = self.indexer.index_folder(folder)

        messagebox.showinfo("Indexed", f"Indexed approx {count} files from {folder}")

        # refresh results

        self.on_search_key()

    def add_command_dialog(self):

        dlg = tk.Toplevel(self)

        dlg.title("Add Command / App")

        dlg.geometry("500x150")

        tk.Label(dlg, text="Title:").pack(anchor="w", padx=8, pady=(8,0))

        title_e = ttk.Entry(dlg, width=60)

        title_e.pack(padx=8)

        tk.Label(dlg, text="Command or Path:").pack(anchor="w", padx=8, pady=(8,0))

        path_e = ttk.Entry(dlg, width=60)

        path_e.pack(padx=8)

        def add():

            t = title_e.get().strip() or Path(path_e.get()).name

            p = path_e.get().strip()

            if not p:

                messagebox.showwarning("Input", "Please provide a command or path")

                return

            typ = "cmd" if (" " in p or os.sep not in p and not Path(p).exists()) else "file"

            self.indexer.add_item(title=t, path=p, typ=typ)

            dlg.destroy()

            self.on_search_key()

        ttk.Button(dlg, text="Add", command=add).pack(pady=8)

    def close(self):

        try:

            self.grab_release()

        except:

            pass

        self.destroy()

# ------------------------------

# Main App Window

# ------------------------------

class PaletteApp:

    def __init__(self, root):

        self.root = root

        root.title("Command Palette Launcher")

        root.geometry("700x120")

        self.indexer = FileIndexer()

        self.indexer.add_common_apps()

        # Add a few demo entries (including uploaded file path)

        if Path(DEMO_FILE).exists():

            self.indexer.add_item(title=Path(DEMO_FILE).name, path=str(DEMO_FILE), typ="file")

        # Top UI

        frame = ttk.Frame(root, padding=12)

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

        ttk.Label(frame, text="Press Ctrl+P to open command palette", font=("Arial", 12)).pack(anchor="w")

        ttk.Button(frame, text="Open Palette (Ctrl+P)", command=self.open_palette).pack(pady=10, anchor="w")

        ttk.Button(frame, text="Index Folder", command=self.index_folder).pack(side="left")

        ttk.Button(frame, text="Exit", command=root.quit).pack(side="right")

        # register global hotkey in a background thread (if available)

        if KEYBOARD_AVAILABLE:

            t = threading.Thread(target=self.register_global_hotkey, daemon=True)

            t.start()

        else:

            print("keyboard package not available — global hotkey disabled. Use app's Ctrl+P instead.")

        # bind Ctrl+P inside the Tk window too

        root.bind_all("<Control-p>", lambda e: self.open_palette())

    def open_palette(self):

        # open modal CommandPalette

        cp = CommandPalette(self.root, self.indexer)

    def index_folder(self):

        folder = filedialog.askdirectory()

        if not folder:

            return

        count = self.indexer.index_folder(folder)

        messagebox.showinfo("Indexed", f"Indexed approx {count} files")

    def register_global_hotkey(self):

        """

        Register Ctrl+P as a global hotkey using keyboard module.

        When pressed, we must bring the Tk window to front and open palette.

        """

        try:

            # On some systems, keyboard requires admin privileges. If it fails, we catch and disable.

            keyboard.add_hotkey("ctrl+p", lambda: self.trigger_from_global())

            keyboard.wait()  # keep the listener alive

        except Exception as e:

            print("Global hotkey registration failed:", e)

    def trigger_from_global(self):

        # Because keyboard runs in another thread, schedule UI work in Tk mainloop

        try:

            self.root.after(0, self.open_palette)

            # Try to bring window to front

            try:

                self.root.lift()

                self.root.attributes("-topmost", True)

                self.root.after(500, lambda: self.root.attributes("-topmost", False))

            except Exception:

                pass

        except Exception as e:

            print("Error triggering palette:", e)

# ------------------------------

# Run

# ------------------------------

def main():

    root = tk.Tk()

    app = PaletteApp(root)

    root.mainloop()

if __name__ == "__main__":

    main()

AI Image Tag Generator

 """

AI Image Tag Generator (transformers + PIL)

- Uses Hugging Face transformers image-classification pipeline (ViT)

- Returns top-k labels as tags with confidence scores

- Default input path is the uploaded file: /mnt/data/image.png

"""

from transformers import pipeline

from PIL import Image

import argparse

import os

# Default path (file uploaded in this session)

DEFAULT_IMAGE_PATH = "/mnt/data/image.png"

def generate_tags(image_path, model_name="google/vit-base-patch16-224", top_k=5):

    """

    Generate tags for an image using a HF transformers image-classification pipeline.

    Returns a list of (label, score) tuples.

    """

    if not os.path.exists(image_path):

        raise FileNotFoundError(f"Image not found: {image_path}")

    classifier = pipeline("image-classification", model=model_name)

    img = Image.open(image_path).convert("RGB")

    preds = classifier(img, top_k=top_k)

    # preds is a list of dicts: [{"label": "...", "score": 0.XX}, ...]

    tags = [(p["label"], float(p["score"])) for p in preds]

    return tags

def pretty_print_tags(tags):

    print("Generated tags:")

    for label, score in tags:

        print(f" - {label}  ({score:.2f})")

def parse_args():

    p = argparse.ArgumentParser(description="AI Image Tag Generator")

    p.add_argument("--image", "-i", default=DEFAULT_IMAGE_PATH, help="Path to input image")

    p.add_argument("--model", "-m", default="google/vit-base-patch16-224", help="HuggingFace model name")

    p.add_argument("--topk", type=int, default=5, help="Number of top tags to return")

    return p.parse_args()

def main():

    args = parse_args()

    try:

        tags = generate_tags(args.image, model_name=args.model, top_k=args.topk)

        pretty_print_tags(tags)

    except Exception as e:

        print("Error:", e)

if __name__ == "__main__":

    main()

Local ML Model Trainer Interface

import streamlit as st

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

from sklearn.model_selection import train_test_split

from sklearn.metrics import (

    accuracy_score, precision_score, recall_score, f1_score,

    mean_squared_error, confusion_matrix

)

from sklearn.preprocessing import StandardScaler

from sklearn.linear_model import LogisticRegression, LinearRegression

from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor

from sklearn.svm import SVC, SVR

from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor

st.set_page_config(page_title="Local ML Model Trainer", layout="wide")

st.title("Local ML Model Trainer Interface")

st.write("Upload a dataset → choose an algorithm → train → view results")

# ────────────────────────────────────────────────

# Upload Dataset

# ────────────────────────────────────────────────

uploaded_file = st.file_uploader("📤 Upload CSV Dataset", type=["csv"])

if uploaded_file:

    df = pd.read_csv(uploaded_file)

    st.success("Dataset Loaded Successfully!")

    st.write("###  Data Preview")

    st.dataframe(df.head())

    st.write("###  Dataset Info")

    st.write(df.describe())

    # Target column selection

    target_col = st.selectbox(" Select Target Column (Y)", df.columns)

    # Feature columns

    X = df.drop(columns=[target_col])

    y = df[target_col]

    # Auto detect problem type

    if df[target_col].dtype == object or df[target_col].nunique() < 15:

        problem_type = "classification"

    else:

        problem_type = "regression"

    st.info(f"Detected Problem Type: **{problem_type.upper()}**")

    # Choose model based on problem type

    if problem_type == "classification":

        model_choice = st.selectbox(

            "Choose Model",

            ["Logistic Regression", "Random Forest Classifier", "SVM Classifier", "KNN Classifier"]

        )

    else:

        model_choice = st.selectbox(

            "Choose Model",

            ["Linear Regression", "Random Forest Regressor", "SVM Regressor", "KNN Regressor"]

        )

    test_size = st.slider("Test Size (Train %)", 0.1, 0.5, 0.2)

    # Train button

    if st.button(" Train Model"):

        # Preprocessing

        scaler = StandardScaler()

        X_scaled = scaler.fit_transform(X.select_dtypes(include=np.number))

        X_train, X_test, y_train, y_test = train_test_split(

            X_scaled, y, test_size=test_size, random_state=42

        )

        # Model Selection

        if model_choice == "Logistic Regression":

            model = LogisticRegression()

        elif model_choice == "Random Forest Classifier":

            model = RandomForestClassifier()

        elif model_choice == "SVM Classifier":

            model = SVC()

        elif model_choice == "KNN Classifier":

            model = KNeighborsClassifier()

        elif model_choice == "Linear Regression":

            model = LinearRegression()

        elif model_choice == "Random Forest Regressor":

            model = RandomForestRegressor()

        elif model_choice == "SVM Regressor":

            model = SVR()

        elif model_choice == "KNN Regressor":

            model = KNeighborsRegressor()

        # Train

        model.fit(X_train, y_train)

        y_pred = model.predict(X_test)

        st.success("Model Trained Successfully!")

        # ────────────────────────────────────────────────

        # Show Metrics

        # ────────────────────────────────────────────────

        st.write("## 📈 Model Performance")

        if problem_type == "classification":

            st.write("### 🔹 Classification Metrics")

            st.write(f"Accuracy: **{accuracy_score(y_test, y_pred):.4f}**")

            st.write(f"Precision: **{precision_score(y_test, y_pred, average='weighted'):.4f}**")

            st.write(f"Recall: **{recall_score(y_test, y_pred, average='weighted'):.4f}**")

            st.write(f"F1 Score: **{f1_score(y_test, y_pred, average='weighted'):.4f}**")

            # Confusion Matrix

            cm = confusion_matrix(y_test, y_pred)

            fig, ax = plt.subplots(figsize=(5, 4))

            sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", ax=ax)

            st.write("###  Confusion Matrix")

            st.pyplot(fig)

        else:

            st.write("### 🔹 Regression Metrics")

            rmse = np.sqrt(mean_squared_error(y_test, y_pred))

            st.write(f"RMSE: **{rmse:.4f}**")

        # ────────────────────────────────────────────────

        # Feature Importance (for tree models)

        # ────────────────────────────────────────────────

        if "Forest" in model_choice:

            st.write("##  Feature Importance")

            importance = model.feature_importances_

            fig, ax = plt.subplots(figsize=(6, 4))

            sns.barplot(x=importance, y=X.columns, ax=ax)

            st.pyplot(fig)