Puzzle Image Generator

 pip install pillow

puzzle.py

import tkinter as tk

from PIL import Image, ImageTk

import random

GRID_SIZE = 3  # 3x3 puzzle

TILE_SIZE = 100  # Pixel size for each tile

IMAGE_PATH = "sample.jpg"  # Replace with your image path

class PuzzleGame:

    def __init__(self, root):

        self.root = root

        self.root.title("🧩 Image Puzzle Game")

        self.image = Image.open(IMAGE_PATH)

        self.image = self.image.resize((TILE_SIZE * GRID_SIZE, TILE_SIZE * GRID_SIZE))

        self.tiles = []

        self.tile_images = []

        self.buttons = []

        self.empty_pos = (GRID_SIZE - 1, GRID_SIZE - 1)

        self.create_tiles()

        self.shuffle_tiles()

        self.draw_tiles()

    def create_tiles(self):

        for row in range(GRID_SIZE):

            row_tiles = []

            for col in range(GRID_SIZE):

                if (row, col) == self.empty_pos:

                    row_tiles.append(None)

                    continue

                left = col * TILE_SIZE

                upper = row * TILE_SIZE

                right = left + TILE_SIZE

                lower = upper + TILE_SIZE

                tile = self.image.crop((left, upper, right, lower))

                tk_img = ImageTk.PhotoImage(tile)

                self.tile_images.append(tk_img)

                row_tiles.append(tk_img)

            self.tiles.append(row_tiles)

    def shuffle_tiles(self):

        # Flatten and shuffle the tiles

        flat_tiles = [tile for row in self.tiles for tile in row if tile is not None]

        random.shuffle(flat_tiles)

        idx = 0

        for row in range(GRID_SIZE):

            for col in range(GRID_SIZE):

                if (row, col) == self.empty_pos:

                    continue

                self.tiles[row][col] = flat_tiles[idx]

                idx += 1

    def draw_tiles(self):

        for row in range(GRID_SIZE):

            for col in range(GRID_SIZE):

                btn = tk.Button(self.root, image=self.tiles[row][col],

                                command=lambda r=row, c=col: self.move_tile(r, c))

                btn.grid(row=row, column=col)

                self.buttons.append(btn)

    def move_tile(self, r, c):

        er, ec = self.empty_pos

        if abs(er - r) + abs(ec - c) == 1:  # Must be adjacent

            # Swap tiles

            self.tiles[er][ec], self.tiles[r][c] = self.tiles[r][c], self.tiles[er][ec]

            self.empty_pos = (r, c)

            self.update_tiles()

    def update_tiles(self):

        for row in range(GRID_SIZE):

            for col in range(GRID_SIZE):

                btn = self.root.grid_slaves(row=row, column=col)[0]

                img = self.tiles[row][col]

                if img:

                    btn.config(image=img)

                else:

                    btn.config(image='', text='')

if __name__ == "__main__":

    root = tk.Tk()

    game = PuzzleGame(root)

    root.mainloop()

Command Palette GUI app

pip install fuzzywuzzy python-Levenshtein

import tkinter as tk

from tkinter import messagebox

import subprocess

import os

from fuzzywuzzy import process

# Sample commands/apps to match

COMMANDS = {

    "Open Notepad": "notepad",

    "Open Calculator": "calc",

    "Command Prompt": "cmd",

    "Open Task Manager": "taskmgr",

    "Open Paint": "mspaint",

    "Open Explorer": "explorer",

    "Shutdown": "shutdown /s /t 1",

    "Restart": "shutdown /r /t 1",

    "Open Downloads": os.path.expanduser("~/Downloads"),

    "Open VSCode": r"C:\Users\ASUS\AppData\Local\Programs\Microsoft VS Code\Code.exe",  # Modify as needed

}

class CommandPaletteApp:

    def __init__(self, root):

        self.root = root

        self.root.title("Command Palette")

        self.root.geometry("500x300")

        self.root.configure(bg="#1e1e1e")

        self.entry = tk.Entry(self.root, font=("Segoe UI", 16), bg="#252526", fg="white", insertbackground="white")

        self.entry.pack(pady=20, padx=20, fill="x")

        self.entry.bind("<KeyRelease>", self.update_suggestions)

        self.entry.bind("<Return>", self.execute_selection)

        self.listbox = tk.Listbox(self.root, font=("Segoe UI", 14), bg="#1e1e1e", fg="white", selectbackground="#007acc")

        self.listbox.pack(padx=20, fill="both", expand=True)

        self.listbox.bind("<Double-Button-1>", self.execute_selection)

        self.commands = list(COMMANDS.keys())

        self.update_list(self.commands)

    def update_suggestions(self, event=None):

        typed = self.entry.get()

        if typed == "":

            self.update_list(self.commands)

        else:

            results = process.extract(typed, self.commands, limit=8)

            self.update_list([r[0] for r in results if r[1] > 40])

    def update_list(self, data):

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

        for item in data:

            self.listbox.insert(tk.END, item)

    def execute_selection(self, event=None):

        selection = self.listbox.get(tk.ACTIVE)

        if selection in COMMANDS:

            command = COMMANDS[selection]

            try:

                if os.path.isfile(command):

                    subprocess.Popen(command)

                elif os.path.isdir(command):

                    os.startfile(command)

                else:

                    subprocess.Popen(command, shell=True)

            except Exception as e:

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

        else:

            messagebox.showinfo("Not Found", "No matching command to run.")

if __name__ == "__main__":

    root = tk.Tk()

    app = CommandPaletteApp(root)

    root.mainloop()

Social Media Content Scheduler

Install Dependencies

pip install streamlit schedule selenium

Project Structure

social_scheduler/

├── scheduler.py

├── social_scheduler_app.py

├── database.db  (auto-created)

Streamlit App – social_scheduler_app.py







import streamlit as st

import sqlite3

import datetime

# === DB Setup ===

conn = sqlite3.connect('database.db', check_same_thread=False)

c = conn.cursor()

c.execute('''CREATE TABLE IF NOT EXISTS posts

             (id INTEGER PRIMARY KEY AUTOINCREMENT,

              platform TEXT, 

              content TEXT, 

              post_time TEXT)''')

conn.commit()

# === Functions ===

def add_post(platform, content, post_time):

    c.execute("INSERT INTO posts (platform, content, post_time) VALUES (?, ?, ?)", 

              (platform, content, post_time))

    conn.commit()

def get_all_posts():

    c.execute("SELECT * FROM posts ORDER BY post_time")

    return c.fetchall()

def delete_post(post_id):

    c.execute("DELETE FROM posts WHERE id = ?", (post_id,))

    conn.commit()

# === Streamlit UI ===

st.title("📅 Social Media Content Scheduler")

with st.form("post_form"):

    platform = st.selectbox("Platform", ["Twitter", "LinkedIn", "Facebook", "Instagram"])

    content = st.text_area("Post Content", max_chars=500)

    post_time = st.time_input("Post Time (24H)")

    submit = st.form_submit_button("➕ Schedule Post")

    if submit:

        post_datetime = datetime.datetime.combine(datetime.date.today(), post_time)

        add_post(platform, content, post_datetime.strftime("%Y-%m-%d %H:%M:%S"))

        st.success("✅ Post scheduled!")

st.subheader("📋 Scheduled Posts")

posts = get_all_posts()

for post in posts:

    st.markdown(f"**[{post[1]}]** {post[2]}  \n⏰ {post[3]}")

    if st.button(f"❌ Delete", key=post[0]):

        delete_post(post[0])

        st.experimental_rerun()

Background Scheduler – scheduler.py




import sqlite3

import schedule

import time

import datetime

from selenium import webdriver

from selenium.webdriver.common.by import By

# === Dummy Post Logic ===

def post_to_platform(platform, content):

    print(f"🟢 Posting to {platform}: {content}")

    # You can replace below with Selenium logic to auto-login and post

# === Actual Scheduler ===

def check_and_post():

    conn = sqlite3.connect('database.db')

    c = conn.cursor()

    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    c.execute("SELECT * FROM posts WHERE post_time <= ?", (now,))

    posts_due = c.fetchall()

    for post in posts_due:

        post_to_platform(post[1], post[2])

        c.execute("DELETE FROM posts WHERE id = ?", (post[0],))

    conn.commit()

    conn.close()

# === Start Scheduler ===

schedule.every(1).minutes.do(check_and_post)

print("⏳ Scheduler running every minute...")

while True:

    schedule.run_pending()

    time.sleep(30)

How to Run It

1. Start Streamlit App:

        streamlit run social_scheduler_app.py

   

   2. In another terminal, run the scheduler:

        python scheduler.py

Travel Planner with Map Integration

import tkinter as tk

from tkinter import messagebox

import requests

import folium

from geopy.geocoders import Nominatim

import webbrowser

# === API KEY ===

WEATHER_API_KEY = "YOUR_OPENWEATHER_API_KEY"

# === Core Functions ===

def get_coordinates(place):

    geolocator = Nominatim(user_agent="travel_planner")

    location = geolocator.geocode(place)

    if location:

        return (location.latitude, location.longitude)

    return None

def get_weather(city):

    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={WEATHER_API_KEY}&units=metric"

    response = requests.get(url)

    data = response.json()

    if data.get("main"):

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

        weather = data["weather"][0]["description"]

        return f"{temp}°C, {weather}"

    return "Not found"

def estimate_cost(destinations):

    return len(destinations) * 1500  # ₹1500 per destination (sample logic)

def show_map(destinations):

    if not destinations:

        messagebox.showerror("Error", "No destinations added!")

        return

    m = folium.Map(location=[20.5937, 78.9629], zoom_start=5)

    for city in destinations:

        coord = get_coordinates(city)

        if coord:

            weather = get_weather(city)

            folium.Marker(coord, tooltip=f"{city}: {weather}").add_to(m)

        else:

            messagebox.showwarning("Warning", f"Could not locate {city}")

    # Optional: Add route lines

    coords = [get_coordinates(city) for city in destinations if get_coordinates(city)]

    if len(coords) > 1:

        folium.PolyLine(coords, color="blue", weight=2.5).add_to(m)

    m.save("travel_map.html")

    webbrowser.open("travel_map.html")

# === GUI ===

destinations = []

def add_destination():

    city = city_entry.get()

    if city:

        destinations.append(city)

        city_listbox.insert(tk.END, city)

        city_entry.delete(0, tk.END)

def clear_destinations():

    destinations.clear()

    city_listbox.delete(0, tk.END)

def plan_trip():

    if not destinations:

        messagebox.showwarning("Empty", "Add destinations first.")

        return

    cost = estimate_cost(destinations)

    show_map(destinations)

    messagebox.showinfo("Trip Estimate", f"🗺️ Trip planned for {len(destinations)} places.\nEstimated Cost: ₹{cost}")

root = tk.Tk()

root.title("🧳 Travel Planner")

root.geometry("400x450")

tk.Label(root, text="Enter Destination City").pack(pady=5)

city_entry = tk.Entry(root, width=30)

city_entry.pack(pady=5)

tk.Button(root, text="➕ Add", command=add_destination).pack()

city_listbox = tk.Listbox(root, width=40)

city_listbox.pack(pady=10)

tk.Button(root, text="🗺️ Plan Trip", command=plan_trip).pack(pady=10)

tk.Button(root, text="❌ Clear All", command=clear_destinations).pack()

root.mainloop()

System Cleanup Scheduler

import os

import shutil

import hashlib

import schedule

import time

from datetime import datetime, timedelta

# === CONFIG ===

TEMP_DIRS = ["temp"]

LOG_DIRS = ["logs"]

DUPLICATE_SCAN_DIRS = ["temp", "logs"]

LOG_EXPIRY_DAYS = 7

# === 1. Delete temp files ===

def clean_temp_folders():

    print("🧹 Cleaning temp folders...")

    for folder in TEMP_DIRS:

        for filename in os.listdir(folder):

            file_path = os.path.join(folder, filename)

            try:

                if os.path.isfile(file_path) or os.path.islink(file_path):

                    os.remove(file_path)

                    print(f"Deleted file: {file_path}")

                elif os.path.isdir(file_path):

                    shutil.rmtree(file_path)

                    print(f"Deleted folder: {file_path}")

            except Exception as e:

                print(f"❌ Failed to delete {file_path}: {e}")

# === 2. Delete old logs ===

def delete_old_logs():

    print("📁 Deleting old logs...")

    for folder in LOG_DIRS:

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

            for file in files:

                file_path = os.path.join(root, file)

                try:

                    file_time = datetime.fromtimestamp(os.path.getmtime(file_path))

                    if datetime.now() - file_time > timedelta(days=LOG_EXPIRY_DAYS):

                        os.remove(file_path)

                        print(f"🗑️ Removed old log: {file_path}")

                except Exception as e:

                    print(f"❌ Error checking {file_path}: {e}")

# === 3. Delete duplicate files ===

def delete_duplicates():

    print("🔍 Searching for duplicates...")

    hashes = {}

    for folder in DUPLICATE_SCAN_DIRS:

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

            for file in files:

                path = os.path.join(root, file)

                try:

                    with open(path, 'rb') as f:

                        file_hash = hashlib.md5(f.read()).hexdigest()

                    if file_hash in hashes:

                        os.remove(path)

                        print(f"❌ Duplicate removed: {path}")

                    else:

                        hashes[file_hash] = path

                except Exception as e:

                    print(f"❌ Error reading {path}: {e}")

# === 4. Master cleanup function ===

def run_cleanup():

    print(f"\n🔧 Running system cleanup @ {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

    clean_temp_folders()

    delete_old_logs()

    delete_duplicates()

    print("✅ Cleanup complete.")

# === 5. Scheduler ===

schedule.every().sunday.at("08:00").do(run_cleanup)

print("🕒 System Cleanup Scheduler started... (Press Ctrl+C to exit)")

run_cleanup()  # Run once on start

while True:

    schedule.run_pending()

    time.sleep(60)