Python for Engineers : February 2025

Resume Parser & Analyzer

pip install spacy pdfminer.six python-docx pandas nltk

python -m spacy download en_core_web_sm

import re

import spacy

import pdfminer.high_level

import docx

import nltk

from collections import Counter

nltk.download("stopwords")

from nltk.corpus import stopwords

# Load spaCy NLP model

nlp = spacy.load("en_core_web_sm")

# Function to extract text from PDF

def extract_text_from_pdf(pdf_path):

return pdfminer.high_level.extract_text(pdf_path)

# Function to extract text from DOCX

def extract_text_from_docx(docx_path):

doc = docx.Document(docx_path)

return "\n".join([para.text for para in doc.paragraphs])

# Function to extract email from text

def extract_email(text):

email_pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"

emails = re.findall(email_pattern, text)

return emails[0] if emails else None

# Function to extract phone number from text

def extract_phone(text):

phone_pattern = r"\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}"

phones = re.findall(phone_pattern, text)

return phones[0] if phones else None

# Function to extract skills from text

def extract_skills(text):

skills_list = ["Python", "Java", "C++", "Machine Learning", "Data Science", "SQL", "Django", "React", "Flask"]

found_skills = [skill for skill in skills_list if skill.lower() in text.lower()]

return found_skills

# Function to extract name using NLP

def extract_name(text):

doc = nlp(text)

for ent in doc.ents:

if ent.label_ == "PERSON":

return ent.text

return None

# Function to match skills with a job description

def match_skills(resume_skills, job_description):

job_tokens = nltk.word_tokenize(job_description.lower())

stop_words = set(stopwords.words("english"))

filtered_job_tokens = [word for word in job_tokens if word not in stop_words]

skill_match_count = sum(1 for skill in resume_skills if skill.lower() in filtered_job_tokens)

match_percentage = (skill_match_count / len(resume_skills)) * 100 if resume_skills else 0

return round(match_percentage, 2)

# Main function

def analyze_resume(file_path, job_description):

# Extract text

text = extract_text_from_pdf(file_path) if file_path.endswith(".pdf") else extract_text_from_docx(file_path)

# Extract details

name = extract_name(text)

email = extract_email(text)

phone = extract_phone(text)

skills = extract_skills(text)

match_percentage = match_skills(skills, job_description)

# Display results

print("\n📄 Resume Analysis Results:")

print(f"👤 Name: {name}")

print(f"📧 Email: {email}")

print(f"📞 Phone: {phone}")

print(f"🛠 Skills: {', '.join(skills)}")

print(f"✅ Skill Match with Job: {match_percentage}%")

return {"name": name, "email": email, "phone": phone, "skills": skills, "match_percentage": match_percentage}

Automated File Organizer

import os

import shutil

# Define file categories with their extensions

FILE_CATEGORIES = {

"Images": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg"],

"Documents": [".pdf", ".docx", ".txt", ".xlsx", ".pptx", ".csv"],

"Videos": [".mp4", ".avi", ".mkv", ".mov"],

"Music": [".mp3", ".wav", ".flac"],

"Archives": [".zip", ".rar", ".tar", ".gz"],

"Programs": [".exe", ".msi", ".dmg"],

"Others": []

}

def organize_files(folder_path):

"""Organizes files into categorized folders based on extensions."""

if not os.path.exists(folder_path):

print(f"Error: The folder '{folder_path}' does not exist.")

return

# Create folders if they don't exist

for category in FILE_CATEGORIES.keys():

category_path = os.path.join(folder_path, category)

os.makedirs(category_path, exist_ok=True)

# Iterate through all files in the folder

for file_name in os.listdir(folder_path):

file_path = os.path.join(folder_path, file_name)

# Skip directories

if os.path.isdir(file_path):

continue

# Get file extension

file_ext = os.path.splitext(file_name)[1].lower()

# Determine the correct category for the file

destination_folder = "Others" # Default category

for category, extensions in FILE_CATEGORIES.items():

if file_ext in extensions:

destination_folder = category

break

# Move the file to the correct folder

shutil.move(file_path, os.path.join(folder_path, destination_folder, file_name))

print(f"Moved: {file_name} → {destination_folder}")

print("✅ File organization completed successfully!")

# Run the script

if __name__ == "__main__":

folder_to_organize = input("Enter the folder path to organize: ")

organize_files(folder_to_organize)

Face Attendance System

import cv2

import numpy as np

import face_recognition

import os

import csv

from datetime import datetime

# Folder containing images of known faces

KNOWN_FACES_DIR = "known_faces"

ATTENDANCE_FILE = "attendance.csv"

# Load known face encodings and names

known_encodings = []

known_names = []

for filename in os.listdir(KNOWN_FACES_DIR):

image_path = os.path.join(KNOWN_FACES_DIR, filename)

image = face_recognition.load_image_file(image_path)

encoding = face_recognition.face_encodings(image)[0]

known_encodings.append(encoding)

known_names.append(os.path.splitext(filename)[0]) # Remove file extension

# Initialize webcam

video_capture = cv2.VideoCapture(0)

# Function to mark attendance

def mark_attendance(name):

with open(ATTENDANCE_FILE, "a", newline="") as file:

writer = csv.writer(file)

now = datetime.now()

time_str = now.strftime("%H:%M:%S")

date_str = now.strftime("%Y-%m-%d")

writer.writerow([name, date_str, time_str])

# Create CSV file with headers if it doesn't exist

if not os.path.exists(ATTENDANCE_FILE):

with open(ATTENDANCE_FILE, "w", newline="") as file:

writer = csv.writer(file)

writer.writerow(["Name", "Date", "Time"])

# Process video stream

while True:

ret, frame = video_capture.read()

if not ret:

break

small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25) # Optimize performance

rgb_frame = cv2.cvtColor(small_frame, cv2.COLOR_BGR2RGB)

# Detect faces in the frame

face_locations = face_recognition.face_locations(rgb_frame)

face_encodings = face_recognition.face_encodings(rgb_frame, face_locations)

for encoding, location in zip(face_encodings, face_locations):

matches = face_recognition.compare_faces(known_encodings, encoding)

name = "Unknown"

if True in matches:

index = matches.index(True)

name = known_names[index]

mark_attendance(name) # Mark attendance in CSV

# Draw bounding box around detected face

top, right, bottom, left = [v * 4 for v in location]

cv2.rectangle(frame, (left, top), (right, bottom), (0, 255, 0), 2)

cv2.putText(frame, name, (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)

cv2.imshow("Face Attendance System", frame)

if cv2.waitKey(1) & 0xFF == ord("q"):

break

video_capture.release()

cv2.destroyAllWindows()

Music Playlist Manager

import os

import tkinter as tk

from tkinter import filedialog, messagebox

import pygame

class MusicPlayer:

def __init__(self, root):

self.root = root

self.root.title("Music Playlist Manager 🎵")

self.root.geometry("500x400")

pygame.init()

pygame.mixer.init()

self.playlist = []

self.current_song_index = -1

self.is_paused = False

# GUI Components

self.playlist_box = tk.Listbox(root, selectmode=tk.SINGLE, bg="white", fg="black", width=60, height=15)

self.playlist_box.pack(pady=10)

btn_frame = tk.Frame(root)

btn_frame.pack()

tk.Button(btn_frame, text="Add Song", command=self.add_song).grid(row=0, column=0, padx=5)

tk.Button(btn_frame, text="Remove Song", command=self.remove_song).grid(row=0, column=1, padx=5)

tk.Button(btn_frame, text="Play", command=self.play_song).grid(row=0, column=2, padx=5)

tk.Button(btn_frame, text="Pause", command=self.pause_song).grid(row=0, column=3, padx=5)

tk.Button(btn_frame, text="Resume", command=self.resume_song).grid(row=0, column=4, padx=5)

tk.Button(btn_frame, text="Stop", command=self.stop_song).grid(row=0, column=5, padx=5)

self.current_song_label = tk.Label(root, text="Now Playing: None", fg="blue", font=("Arial", 10, "bold"))

self.current_song_label.pack(pady=10)

def add_song(self):

file_path = filedialog.askopenfilename(filetypes=[("MP3 Files", "*.mp3")])

if file_path:

self.playlist.append(file_path)

self.playlist_box.insert(tk.END, os.path.basename(file_path))

def remove_song(self):

selected_index = self.playlist_box.curselection()

if selected_index:

index = selected_index[0]

self.playlist_box.delete(index)

del self.playlist[index]

def play_song(self):

selected_index = self.playlist_box.curselection()

if selected_index:

index = selected_index[0]

self.current_song_index = index

song_path = self.playlist[index]

pygame.mixer.music.load(song_path)

pygame.mixer.music.play()

self.is_paused = False

self.current_song_label.config(text=f"Now Playing: {os.path.basename(song_path)}")

def pause_song(self):

if not self.is_paused:

pygame.mixer.music.pause()

self.is_paused = True

def resume_song(self):

if self.is_paused:

pygame.mixer.music.unpause()

self.is_paused = False

def stop_song(self):

pygame.mixer.music.stop()

self.current_song_label.config(text="Now Playing: None")

# Run the application

if __name__ == "__main__":

root = tk.Tk()

app = MusicPlayer(root)

root.mainloop()

Personal Finance Tracker

import tkinter as tk

from tkinter import ttk, messagebox

import sqlite3

import matplotlib.pyplot as plt

# Database Setup

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

cursor = conn.cursor()

cursor.execute("""

CREATE TABLE IF NOT EXISTS transactions (

id INTEGER PRIMARY KEY AUTOINCREMENT,

date TEXT,

category TEXT,

amount REAL,

type TEXT

)

""")

conn.commit()

class FinanceTracker:

def __init__(self, root):

self.root = root

self.root.title("Personal Finance Tracker 💰")

self.root.geometry("600x500")

# UI Components

tk.Label(root, text="Date (YYYY-MM-DD):").grid(row=0, column=0, padx=10, pady=5, sticky="w")

self.date_entry = tk.Entry(root, width=30)

self.date_entry.grid(row=0, column=1, padx=10, pady=5)

tk.Label(root, text="Category:").grid(row=1, column=0, padx=10, pady=5, sticky="w")

self.category_entry = tk.Entry(root, width=30)

self.category_entry.grid(row=1, column=1, padx=10, pady=5)

tk.Label(root, text="Amount:").grid(row=2, column=0, padx=10, pady=5, sticky="w")

self.amount_entry = tk.Entry(root, width=30)

self.amount_entry.grid(row=2, column=1, padx=10, pady=5)

tk.Label(root, text="Transaction Type:").grid(row=3, column=0, padx=10, pady=5, sticky="w")

self.type_var = tk.StringVar(value="Expense")

self.type_dropdown = ttk.Combobox(root, textvariable=self.type_var, values=["Expense", "Income"], width=28)

self.type_dropdown.grid(row=3, column=1, padx=10, pady=5)

self.type_dropdown.current(0)

# Buttons - Expanded Width

tk.Button(root, text="Add Transaction", command=self.add_transaction, width=20).grid(row=4, column=0, columnspan=2, pady=10)

tk.Button(root, text="Show Transactions", command=self.show_transactions, width=20).grid(row=5, column=0, columnspan=2, pady=5)

tk.Button(root, text="View Report", command=self.view_report, width=20).grid(row=6, column=0, columnspan=2, pady=5)

# Transaction List Display

self.tree = ttk.Treeview(root, columns=("ID", "Date", "Category", "Amount", "Type"), show="headings")

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

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

self.tree.heading("Category", text="Category")

self.tree.heading("Amount", text="Amount")

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

self.tree.column("ID", width=30)

self.tree.column("Date", width=100)

self.tree.column("Category", width=100)

self.tree.column("Amount", width=80)

self.tree.column("Type", width=80)

self.tree.grid(row=7, column=0, columnspan=2, padx=10, pady=10)

def add_transaction(self):

date = self.date_entry.get()

category = self.category_entry.get()

amount = self.amount_entry.get()

trans_type = self.type_var.get()

if not date or not category or not amount or not trans_type:

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

return

try:

amount = float(amount)

cursor.execute("INSERT INTO transactions (date, category, amount, type) VALUES (?, ?, ?, ?)",

(date, category, amount, trans_type))

conn.commit()

messagebox.showinfo("Success", "Transaction added successfully!")

self.clear_entries()

except ValueError:

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

def show_transactions(self):

for item in self.tree.get_children():

self.tree.delete(item)

cursor.execute("SELECT * FROM transactions")

for row in cursor.fetchall():

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

def view_report(self):

cursor.execute("SELECT category, SUM(amount) FROM transactions WHERE type='Expense' GROUP BY category")

data = cursor.fetchall()

if not data:

messagebox.showinfo("Report", "No expenses recorded.")

return

categories, amounts = zip(*data)

plt.figure(figsize=(6, 6))

plt.pie(amounts, labels=categories, autopct="%1.1f%%", startangle=140)

plt.title("Expense Breakdown")

plt.show()

def clear_entries(self):

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

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

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

self.type_var.set("Expense")

# Run the application

if __name__ == "__main__":

root = tk.Tk()

app = FinanceTracker(root)

root.mainloop()

Real-Time Weather Dashboard

Get an API Key from OpenWeather

import tkinter as tk

from tkinter import messagebox

import requests

# OpenWeather API Key (Replace with your own key)

API_KEY = "YOUR_OPENWEATHER_API_KEY"

BASE_URL = "http://api.openweathermap.org/data/2.5/weather"

# Function to fetch weather data

def get_weather():

city = city_entry.get()

if not city:

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

return

params = {"q": city, "appid": API_KEY, "units": "metric"}

response = requests.get(BASE_URL, params=params)

if response.status_code == 200:

data = response.json()

weather = data["weather"][0]["description"].capitalize()

temp = data["main"]["temp"]

humidity = data["main"]["humidity"]

result_label.config(text=f"🌍 City: {city}\n🌡️ Temperature: {temp}°C\n💧 Humidity: {humidity}%\n☁️ Condition: {weather}")

else:

messagebox.showerror("Error", "City not found! Please try again.")

# GUI setup

root = tk.Tk()

root.title("Real-Time Weather Dashboard")

root.geometry("400x350")

tk.Label(root, text="Enter City Name:", font=("Arial", 14)).pack(pady=10)

city_entry = tk.Entry(root, font=("Arial", 12), width=25)

city_entry.pack(pady=5)

tk.Button(root, text="Get Weather", font=("Arial", 12), command=get_weather).pack(pady=10)

result_label = tk.Label(root, text="", font=("Arial", 14), justify="left")

result_label.pack(pady=20)

# Run GUI

root.mainloop()

Online Python Compiler 💻

pip install flask

app.py

from flask import Flask, render_template, request, jsonify

import subprocess

app = Flask(__name__)

@app.route("/")

def home():

return render_template("index.html")

@app.route("/run", methods=["POST"])

def run_code():

code = request.json.get("code", "")

try:

# Run the code in a restricted subprocess

result = subprocess.run(

["python", "-c", code],

capture_output=True,

text=True,

timeout=5

)

output = result.stdout if result.stdout else result.stderr

except Exception as e:

output = str(e)

return jsonify({"output": output})

if __name__ == "__main__":

app.run(debug=True)

templates/index.html

<!DOCTYPE html>

<head>

<title>Online Python Compiler</title>

<style>

body { font-family: Arial, sans-serif; text-align: center; }

#editor { width: 80%; height: 300px; margin: auto; border: 1px solid #ddd; }

#output { white-space: pre-wrap; background: #f4f4f4; padding: 10px; margin-top: 10px; width: 80%; }

</style>

</head>

<body>

<h1>Online Python Compiler 💻</h1>

<div id="editor">print("Hello, World!")</div>

<pre id="output">Output will appear here...</pre>

var editor = ace.edit("editor");

editor.setTheme("ace/theme/monokai");

editor.session.setMode("ace/mode/python");

function runCode() {

let code = editor.getValue();

fetch("/run", {

method: "POST",

headers: { "Content-Type": "application/json" },

body: JSON.stringify({ code: code })

})

.then(response => response.json())

.then(data => document.getElementById("output").innerText = data.output);

}

</script>

</body>

</html>

Flashcard App for Learning

import tkinter as tk

import json

import random

# File to store flashcards

FLASHCARDS_FILE = "flashcards.json"

class FlashcardApp:

def __init__(self, root):

self.root = root

self.root.title("Flashcard App")

self.root.geometry("400x300")

self.flashcards = self.load_flashcards()

self.current_flashcard = {}

# UI Elements

self.label = tk.Label(root, text="Press 'Next' to start!", font=("Arial", 14), wraplength=350)

self.label.pack(pady=20)

self.flip_button = tk.Button(root, text="Flip", command=self.flip_card)

self.flip_button.pack()

self.next_button = tk.Button(root, text="Next", command=self.next_card)

self.next_button.pack()

self.add_button = tk.Button(root, text="Add Flashcard", command=self.add_flashcard)

self.add_button.pack()

def load_flashcards(self):

try:

with open(FLASHCARDS_FILE, "r") as file:

return json.load(file)

except FileNotFoundError:

return []

def save_flashcards(self):

with open(FLASHCARDS_FILE, "w") as file:

json.dump(self.flashcards, file)

def next_card(self):

if not self.flashcards:

self.label.config(text="No flashcards available. Add some!")

else:

self.current_flashcard = random.choice(self.flashcards)

self.label.config(text=f"Q: {self.current_flashcard['question']}")

def flip_card(self):

if self.current_flashcard:

self.label.config(text=f"A: {self.current_flashcard['answer']}")

def add_flashcard(self):

add_window = tk.Toplevel(self.root)

add_window.title("Add Flashcard")

add_window.geometry("300x200")

tk.Label(add_window, text="Question:").pack()

question_entry = tk.Entry(add_window, width=40)

question_entry.pack()

tk.Label(add_window, text="Answer:").pack()

answer_entry = tk.Entry(add_window, width=40)

answer_entry.pack()

def save_new_flashcard():

question = question_entry.get()

answer = answer_entry.get()

if question and answer:

self.flashcards.append({"question": question, "answer": answer})

self.save_flashcards()

add_window.destroy()

save_button = tk.Button(add_window, text="Save", command=save_new_flashcard)

save_button.pack()

# Run the app

root = tk.Tk()

app = FlashcardApp(root)

root.mainloop()

Quiz Game with Leaderboard 🎮

import tkinter as tk

from tkinter import messagebox

import random

import json

# Load questions from a JSON file or use a dictionary

questions = [

{"question": "What keyword is used to define a function in Python?",

"options": ["func", "define", "def", "function"],

"answer": "def"},

{"question": "Which of the following is used to create a loop in Python?",

"options": ["for", "while", "do-while", "Both A and B"],

"answer": "Both A and B"},

{"question": "What is the correct way to open a file in read mode?",

"options": ["open('file.txt', 'r')", "open('file.txt', 'w')", "open('file.txt', 'rw')", "open('file.txt')"],

"answer": "open('file.txt', 'r')"},

{"question": "Which data structure follows the Last In, First Out (LIFO) principle?",

"options": ["Queue", "Stack", "List", "Dictionary"],

"answer": "Stack"},

{"question": "Which method is used to add an element to a list?",

"options": ["append()", "insert()", "extend()", "add()"],

"answer": "append()"},

{"question": "Which library is commonly used for data analysis in Python?",

"options": ["NumPy", "Pandas", "Matplotlib", "Seaborn"],

"answer": "Pandas"},

{"question": "Which symbol is used to comment a single line in Python?",

"options": ["//", "#", "/*", "--"],

"answer": "#"},

{"question": "What will be the output of `len(['Python', 'Java', 'C++'])`?",

"options": ["2", "3", "4", "Error"],

"answer": "3"},

{"question": "What does the `range(5)` function return?",

"options": ["[1,2,3,4,5]", "[0,1,2,3,4]", "(0,1,2,3,4)", "None"],

"answer": "[0,1,2,3,4]"},

{"question": "Which of the following is a mutable data type in Python?",

"options": ["Tuple", "String", "List", "Integer"],

"answer": "List"}

]

# Load leaderboard from file

def load_leaderboard():

try:

with open("leaderboard.json", "r") as f:

return json.load(f)

except FileNotFoundError:

return {}

# Save leaderboard to file

def save_leaderboard(leaderboard):

with open("leaderboard.json", "w") as f:

json.dump(leaderboard, f, indent=4)

class QuizGame:

def __init__(self, root):

self.root = root

self.root.title("Quiz Game with Leaderboard")

self.root.geometry("500x400")

self.score = 0

self.current_question = 0

self.username = ""

self.start_screen()

def start_screen(self):

"""Start screen to enter player's name."""

self.clear_window()

tk.Label(self.root, text="Enter Your Name:", font=("Arial", 14)).pack(pady=10)

self.name_entry = tk.Entry(self.root, font=("Arial", 12))

self.name_entry.pack(pady=5)

tk.Button(self.root, text="Start Quiz", command=self.start_quiz, font=("Arial", 12)).pack(pady=20)

def start_quiz(self):

"""Start the quiz after getting the user's name."""

self.username = self.name_entry.get()

if not self.username:

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

return

random.shuffle(questions)

self.score = 0

self.current_question = 0

self.show_question()

def show_question(self):

"""Display a question and answer options."""

self.clear_window()

if self.current_question < len(questions):

q_data = questions[self.current_question]

self.correct_answer = q_data["answer"]

tk.Label(self.root, text=f"Q{self.current_question + 1}: {q_data['question']}", font=("Arial", 14), wraplength=400).pack(pady=10)

self.answer_var = tk.StringVar()

for option in q_data["options"]:

tk.Radiobutton(self.root, text=option, variable=self.answer_var, value=option, font=("Arial", 12)).pack(anchor="w", padx=20)

tk.Button(self.root, text="Submit", command=self.check_answer, font=("Arial", 12)).pack(pady=10)

else:

self.show_result()

def check_answer(self):

"""Check the selected answer."""

selected_answer = self.answer_var.get()

if not selected_answer:

messagebox.showerror("Error", "Please select an answer!")

return

if selected_answer == self.correct_answer:

self.score += 1

self.current_question += 1

self.show_question()

def show_result(self):

"""Display the final score and update leaderboard."""

self.clear_window()

leaderboard = load_leaderboard()

leaderboard[self.username] = self.score

save_leaderboard(leaderboard)

tk.Label(self.root, text=f"Quiz Over! {self.username}, your score: {self.score}/{len(questions)}", font=("Arial", 14)).pack(pady=10)

tk.Button(self.root, text="View Leaderboard", command=self.show_leaderboard, font=("Arial", 12)).pack(pady=10)

tk.Button(self.root, text="Play Again", command=self.start_screen, font=("Arial", 12)).pack(pady=5)

tk.Button(self.root, text="Exit", command=self.root.quit, font=("Arial", 12)).pack(pady=5)

def show_leaderboard(self):

"""Display the leaderboard."""

self.clear_window()

leaderboard = load_leaderboard()

sorted_leaderboard = sorted(leaderboard.items(), key=lambda x: x[1], reverse=True)

tk.Label(self.root, text="🏆 Leaderboard 🏆", font=("Arial", 16, "bold")).pack(pady=10)

for rank, (player, high_score) in enumerate(sorted_leaderboard, start=1):

tk.Label(self.root, text=f"{rank}. {player} - {high_score}", font=("Arial", 12)).pack()

tk.Button(self.root, text="Back to Menu", command=self.start_screen, font=("Arial", 12)).pack(pady=10)

def clear_window(self):

"""Clear the window for new content."""

for widget in self.root.winfo_children():

widget.destroy()

# Run the application

if __name__ == "__main__":

root = tk.Tk()

app = QuizGame(root)

root.mainloop()

Habit Tracker

import sqlite3

import tkinter as tk

from tkinter import messagebox

# Database Setup

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

cursor = conn.cursor()

cursor.execute("""

CREATE TABLE IF NOT EXISTS habits (

id INTEGER PRIMARY KEY AUTOINCREMENT,

name TEXT NOT NULL,

status TEXT DEFAULT 'Pending'

)

""")

conn.commit()

# Function to add a new habit

def add_habit():

habit_name = habit_entry.get().strip()

if habit_name:

cursor.execute("INSERT INTO habits (name, status) VALUES (?, 'Pending')", (habit_name,))

conn.commit()

habit_entry.delete(0, tk.END)

load_habits()

else:

messagebox.showwarning("Warning", "Please enter a habit name!")

# Function to mark a habit as completed

def complete_habit(habit_id):

cursor.execute("UPDATE habits SET status = 'Completed' WHERE id = ?", (habit_id,))

conn.commit()

load_habits()

# Function to delete a habit

def delete_habit(habit_id):

cursor.execute("DELETE FROM habits WHERE id = ?", (habit_id,))

conn.commit()

load_habits()

# Function to load habits from the database

def load_habits():

habit_list.delete(0, tk.END)

cursor.execute("SELECT id, name, status FROM habits")

for habit in cursor.fetchall():

habit_id, name, status = habit

habit_list.insert(tk.END, f"{habit_id}. {name} - {status}")

# GUI Setup

root = tk.Tk()

root.title("Habit Tracker")

root.geometry("400x500")

tk.Label(root, text="Enter a New Habit:", font=("Arial", 12)).pack(pady=5)

habit_entry = tk.Entry(root, width=40)

habit_entry.pack(pady=5)

tk.Button(root, text="Add Habit", command=add_habit).pack(pady=5)

tk.Label(root, text="Your Habits:", font=("Arial", 12)).pack(pady=5)

habit_list = tk.Listbox(root, width=50, height=10)

habit_list.pack()

tk.Button(root, text="Mark as Completed", command=lambda: complete_habit(habit_list.get(tk.ACTIVE).split('.')[0])).pack(pady=5)

tk.Button(root, text="Delete Habit", command=lambda: delete_habit(habit_list.get(tk.ACTIVE).split('.')[0])).pack(pady=5)

load_habits()

root.mainloop()

Blog Pages