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>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>Online Python Compiler</title>

    <script src="https://cdnjs.cloudflare.com/ajax/libs/ace/1.4.12/ace.js"></script>

    <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>

    <button onclick="runCode()">Run Code</button>

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

    <script>

        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>