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)