Python for Engineers : January 2026

AI Mood-Based Wallpaper Switcher (Windows)

import cv2

import mediapipe as mp

import numpy as np

import ctypes

import os

import time

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

# CONFIGURATION

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

WALLPAPER_DIR = "wallpapers"

DETECTION_INTERVAL = 5 # seconds between wallpaper changes

MOOD_WALLPAPERS = {

"happy": "happy.jpg",

"sad": "sad.jpg",

"angry": "angry.jpg",

"neutral": "neutral.jpg"

}

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

# Windows Wallpaper Setter

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

def set_wallpaper(image_path):

ctypes.windll.user32.SystemParametersInfoW(

20, 0, image_path, 3

)

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

# Face & Landmark Setup

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

mp_face_mesh = mp.solutions.face_mesh

face_mesh = mp_face_mesh.FaceMesh(refine_landmarks=True)

mp_draw = mp.solutions.drawing_utils

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

# Simple Emotion Detection (Rule-Based)

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

def detect_emotion(landmarks):

# Mouth & eyebrow points

mouth_left = landmarks[61]

mouth_right = landmarks[291]

mouth_top = landmarks[13]

mouth_bottom = landmarks[14]

left_eyebrow = landmarks[70]

right_eyebrow = landmarks[300]

mouth_width = abs(mouth_right.x - mouth_left.x)

mouth_height = abs(mouth_bottom.y - mouth_top.y)

eyebrow_height = abs(left_eyebrow.y - right_eyebrow.y)

# Heuristic rules

if mouth_height > 0.035 and mouth_width > 0.04:

return "happy"

elif mouth_height < 0.015:

return "sad"

elif eyebrow_height < 0.01:

return "angry"

else:

return "neutral"

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

# MAIN LOOP

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

def main():

cap = cv2.VideoCapture(0)

last_change = time.time()

current_mood = None

print("🎭 Mood-Based Wallpaper Switcher Started")

print("Press 'Q' to quit.\n")

while True:

ret, frame = cap.read()

if not ret:

break

rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

results = face_mesh.process(rgb)

if results.multi_face_landmarks:

landmarks = results.multi_face_landmarks[0].landmark

mood = detect_emotion(landmarks)

cv2.putText(

frame,

f"Mood: {mood}",

(30, 50),

cv2.FONT_HERSHEY_SIMPLEX,

(0, 255, 0),

)

# Change wallpaper only after interval

if mood != current_mood and time.time() - last_change > DETECTION_INTERVAL:

wallpaper_path = os.path.join(WALLPAPER_DIR, MOOD_WALLPAPERS[mood])

if os.path.exists(wallpaper_path):

set_wallpaper(os.path.abspath(wallpaper_path))

print(f"🖼️ Wallpaper changed → {mood}")

current_mood = mood

last_change = time.time()

cv2.imshow("AI Mood Detector", frame)

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

break

cap.release()

cv2.destroyAllWindows()

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

# RUN

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

if __name__ == "__main__":

main()

Python Audio Noise Cleaner

import librosa

import numpy as np

import noisereduce as nr

import soundfile as sf

import os

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

# CONFIG

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

NOISE_DURATION = 1.0 # seconds used to estimate noise

OUTPUT_SUFFIX = "_cleaned"

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

# Load audio

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

def load_audio(path):

audio, sr = librosa.load(path, sr=None, mono=True)

return audio, sr

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

# Noise reduction

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

def reduce_noise(audio, sr, noise_duration=NOISE_DURATION):

noise_samples = int(noise_duration * sr)

noise_clip = audio[:noise_samples]

reduced = nr.reduce_noise(

y=audio,

sr=sr,

y_noise=noise_clip,

prop_decrease=1.0

)

return reduced

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

# Save cleaned audio

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

def save_audio(original_path, audio, sr):

base, ext = os.path.splitext(original_path)

output_path = f"{base}{OUTPUT_SUFFIX}.wav"

sf.write(output_path, audio, sr)

return output_path

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

# MAIN

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

if __name__ == "__main__":

input_path = input("Enter audio file path (.wav/.mp3): ").strip()

if not os.path.exists(input_path):

print(" File not found.")

exit()

print(" Loading audio...")

audio, sr = load_audio(input_path)

print(" Reducing background noise...")

cleaned_audio = reduce_noise(audio, sr)

output = save_audio(input_path, cleaned_audio, sr)

print("\n Noise reduction complete!")

print(f" Cleaned file saved as: {output}")

Offline Barcode & QR Generator

import tkinter as tk

from tkinter import filedialog, messagebox

from PIL import Image, ImageTk

import qrcode

from pyzbar.pyzbar import decode

import os

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

# MAIN APP

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

class BarcodeQRApp:

def __init__(self, root):

self.root = root

self.root.title("Offline Barcode & QR Suite")

self.root.geometry("520x520")

self.build_ui()

def build_ui(self):

tk.Label(self.root, text="Barcode & QR Generator / Reader",

font=("Arial", 16, "bold")).pack(pady=10)

self.text_entry = tk.Entry(self.root, width=45)

self.text_entry.pack(pady=5)

self.text_entry.insert(0, "Enter text or URL")

tk.Button(self.root, text="Generate QR Code",

command=self.generate_qr).pack(pady=5)

tk.Button(self.root, text="Read QR / Barcode from Image",

command=self.read_code).pack(pady=5)

self.image_label = tk.Label(self.root)

self.image_label.pack(pady=10)

self.result_label = tk.Label(self.root, text="", wraplength=480)

self.result_label.pack(pady=10)

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

# Generate QR

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

def generate_qr(self):

text = self.text_entry.get().strip()

if not text:

messagebox.showerror("Error", "Enter some text!")

return

qr = qrcode.make(text)

file = filedialog.asksaveasfilename(

defaultextension=".png",

filetypes=[("PNG Image", "*.png")]

)

if file:

qr.save(file)

self.display_image(file)

messagebox.showinfo("Saved", f"QR saved at:\n{file}")

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

# Read QR / Barcode

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

def read_code(self):

file = filedialog.askopenfilename(

filetypes=[("Image Files", "*.png *.jpg *.jpeg")]

)

if not file:

return

img = Image.open(file)

self.display_image(file)

decoded = decode(img)

if not decoded:

self.result_label.config(text=" No QR or Barcode detected.")

return

result_text = ""

for d in decoded:

result_text += f"""

Type: {d.type}

Data: {d.data.decode('utf-8')}

---------------------

"""

self.result_label.config(text=result_text)

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

# Display image

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

def display_image(self, path):

img = Image.open(path)

img.thumbnail((250, 250))

self.tk_img = ImageTk.PhotoImage(img)

self.image_label.config(image=self.tk_img)

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

# RUN

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

if __name__ == "__main__":

root = tk.Tk()

app = BarcodeQRApp(root)

root.mainloop()

Music Playlist Deduplicator

import os

import hashlib

import tkinter as tk

from tkinter import ttk, filedialog, messagebox

from tinytag import TinyTag

SUPPORTED_EXT = (".mp3", ".wav", ".flac", ".m4a")

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

# Helpers

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

def file_hash(path, block_size=65536):

"""Compute SHA256 hash of a file."""

h = hashlib.sha256()

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

for block in iter(lambda: f.read(block_size), b""):

h.update(block)

return h.hexdigest()

def get_metadata(path):

"""Extract audio metadata."""

try:

tag = TinyTag.get(path)

return {

"title": (tag.title or "").strip().lower(),

"artist": (tag.artist or "").strip().lower(),

"duration": round(tag.duration or 0, 1)

}

except Exception:

return {"title": "", "artist": "", "duration": 0}

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

# Main App

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

class MusicDeduplicator:

def __init__(self, root):

self.root = root

self.root.title("Music Playlist Deduplicator")

self.root.geometry("900x520")

self.files = []

self.duplicates = []

self.build_ui()

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

def build_ui(self):

top = ttk.Frame(self.root)

top.pack(fill="x", padx=10, pady=10)

ttk.Button(top, text="Select Music Folder", command=self.select_folder).pack(side="left")

ttk.Button(top, text="Scan for Duplicates", command=self.scan).pack(side="left", padx=10)

self.status = ttk.Label(top, text="No folder selected")

self.status.pack(side="left", padx=10)

self.tree = ttk.Treeview(

self.root,

columns=("method", "file1", "file2"),

show="headings"

)

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

self.tree.heading("file1", text="Song A")

self.tree.heading("file2", text="Song B")

self.tree.column("method", width=140)

self.tree.column("file1", width=360)

self.tree.column("file2", width=360)

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

# ---------------- Logic ----------------

def select_folder(self):

self.folder = filedialog.askdirectory()

if self.folder:

self.status.config(text=self.folder)

def scan(self):

if not hasattr(self, "folder"):

messagebox.showerror("Error", "Select a music folder first!")

return

self.tree.delete(*self.tree.get_children())

self.files = []

self.duplicates = []

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

for f in files:

if f.lower().endswith(SUPPORTED_EXT):

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

self.files.append(path)

self.find_duplicates()

self.display_results()

def find_duplicates(self):

# --- 1. Exact file hash duplicates ---

hash_map = {}

for path in self.files:

try:

h = file_hash(path)

if h in hash_map:

self.duplicates.append(("Exact File", hash_map[h], path))

else:

hash_map[h] = path

except Exception:

pass

# --- 2. Metadata duplicates ---

meta_map = {}

for path in self.files:

meta = get_metadata(path)

key = (meta["title"], meta["artist"], meta["duration"])

if key != ("", "", 0):

if key in meta_map:

self.duplicates.append(("Metadata Match", meta_map[key], path))

else:

meta_map[key] = path

def display_results(self):

if not self.duplicates:

messagebox.showinfo("Result", "No duplicate songs found!")

return

for method, f1, f2 in self.duplicates:

self.tree.insert("", "end", values=(method, f1, f2))

messagebox.showinfo(

"Result",

f"Found {len(self.duplicates)} duplicate pairs."

)

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

# RUN

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

if __name__ == "__main__":

root = tk.Tk()

app = MusicDeduplicator(root)

root.mainloop()

Smart Directory Visualizer

import os

import sys

import tkinter as tk

from tkinter import ttk, filedialog, messagebox

import subprocess

import platform

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

# Utility: Open files/folders with default app

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

def open_path(path):

try:

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

os.startfile(path)

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

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

else:

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

except Exception as e:

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

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

# Main App

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

class DirectoryVisualizer:

def __init__(self, root):

self.root = root

self.root.title("Smart Directory Visualizer")

self.root.geometry("800x500")

self.create_ui()

def create_ui(self):

top = ttk.Frame(self.root)

top.pack(fill="x", padx=10, pady=10)

ttk.Button(top, text="Select Folder", command=self.choose_folder).pack(side="left")

self.path_label = ttk.Label(top, text="No folder selected")

self.path_label.pack(side="left", padx=10)

# Treeview

self.tree = ttk.Treeview(self.root)

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

self.tree.heading("#0", text="Folder Structure", anchor="w")

# Scrollbar

scrollbar = ttk.Scrollbar(self.tree, orient="vertical", command=self.tree.yview)

self.tree.configure(yscrollcommand=scrollbar.set)

scrollbar.pack(side="right", fill="y")

# Events

self.tree.bind("<<TreeviewOpen>>", self.on_expand)

self.tree.bind("<Double-1>", self.on_double_click)

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

# Folder selection

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

def choose_folder(self):

folder = filedialog.askdirectory()

if not folder:

return

self.path_label.config(text=folder)

self.tree.delete(*self.tree.get_children())

root_node = self.tree.insert("", "end", text=folder, open=False, values=[folder])

self.tree.set(root_node, "fullpath", folder)

self.add_dummy(root_node)

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

# Lazy loading helpers

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

def add_dummy(self, parent):

self.tree.insert(parent, "end", text="Loading...")

def on_expand(self, event):

node = self.tree.focus()

self.load_children(node)

def load_children(self, parent):

fullpath = self.get_fullpath(parent)

# Remove dummy

self.tree.delete(*self.tree.get_children(parent))

try:

for name in sorted(os.listdir(fullpath)):

path = os.path.join(fullpath, name)

node = self.tree.insert(parent, "end", text=name, open=False)

self.tree.set(node, "fullpath", path)

if os.path.isdir(path):

self.add_dummy(node)

except PermissionError:

pass

def get_fullpath(self, item):

parent = self.tree.parent(item)

if parent:

return os.path.join(self.get_fullpath(parent), self.tree.item(item, "text"))

else:

return self.tree.item(item, "text")

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

# Open file/folder on double click

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

def on_double_click(self, event):

item = self.tree.focus()

path = self.get_fullpath(item)

if os.path.exists(path):

open_path(path)

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

# RUN

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

if __name__ == "__main__":

root = tk.Tk()

app = DirectoryVisualizer(root)

root.mainloop()

Typing Pattern Authentication (Keystroke Biometrics)

import keyboard

import time

import numpy as np

from sklearn.linear_model import LogisticRegression

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

import pickle

PHRASE = "securetyping"

MODEL_FILE = "keystroke_model.pkl"

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

# Capture keystroke timing

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

def capture_keystrokes(prompt):

print("\n" + prompt)

print(f"Type exactly: '{PHRASE}' and press Enter")

timings = []

press_times = {}

def on_press(e):

if e.name == "enter":

return

press_times[e.name] = time.time()

def on_release(e):

if e.name == "enter":

return

if e.name in press_times:

dwell = time.time() - press_times[e.name]

timings.append(dwell)

keyboard.on_press(on_press)

keyboard.on_release(on_release)

typed = input("> ")

keyboard.unhook_all()

if typed != PHRASE:

print(" Incorrect phrase typed.")

return None

return timings

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

# Collect training samples

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

def collect_samples(samples=10):

data = []

print("\n Training Phase")

for i in range(samples):

t = capture_keystrokes(f"Sample {i + 1}/{samples}")

if t:

data.append(t)

min_len = min(len(x) for x in data)

data = [x[:min_len] for x in data]

return np.array(data)

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

# Train ML model

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

def train_model(data):

X = data

y = np.ones(len(X)) # Legitimate user = 1

# Add fake impostor data (noise)

impostor = np.random.uniform(0.05, 0.4, size=X.shape)

X = np.vstack((X, impostor))

y = np.hstack((y, np.zeros(len(impostor))))

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.25, random_state=42

)

model = LogisticRegression()

model.fit(X_train, y_train)

acc = accuracy_score(y_test, model.predict(X_test))

print(f"\n📊 Model Accuracy: {acc * 100:.2f}%")

with open(MODEL_FILE, "wb") as f:

pickle.dump(model, f)

print("✅ Model saved.")

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

# Authenticate user

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

def authenticate():

with open(MODEL_FILE, "rb") as f:

model = pickle.load(f)

t = capture_keystrokes("🔐 Authentication Attempt")

if not t:

return

t = np.array(t).reshape(1, -1)

prediction = model.predict(t)[0]

confidence = model.predict_proba(t)[0][1]

if prediction == 1:

print(f" Access Granted (Confidence: {confidence:.2f})")

else:

print(f" Access Denied (Confidence: {confidence:.2f})")

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

# MAIN

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

if __name__ == "__main__":

print("""

Keystroke Biometrics Demo

1. Train new user

2. Authenticate

""")

choice = input("Choose option (1/2): ").strip()

if choice == "1":

data = collect_samples(samples=8)

train_model(data)

elif choice == "2":

authenticate()

else:

print("Invalid choice.")

PDF Page Comparison Tool

import fitz # PyMuPDF

from PIL import Image, ImageChops, ImageDraw

import difflib

import os

OUTPUT_DIR = "pdf_diff_output"

os.makedirs(OUTPUT_DIR, exist_ok=True)

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

# Extract text from a PDF page

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

def extract_text(pdf_path, page_num):

doc = fitz.open(pdf_path)

if page_num >= len(doc):

return ""

return doc[page_num].get_text()

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

# Render page as image

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

def render_page_image(pdf_path, page_num, zoom=2):

doc = fitz.open(pdf_path)

page = doc[page_num]

mat = fitz.Matrix(zoom, zoom)

pix = page.get_pixmap(matrix=mat)

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

return img

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

# Text Difference

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

def text_diff(text1, text2):

diff = difflib.unified_diff(

text1.splitlines(),

text2.splitlines(),

lineterm=""

)

return "\n".join(diff)

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

# Image Difference (highlight changes)

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

def image_diff(img1, img2):

diff = ImageChops.difference(img1, img2)

diff = diff.convert("RGB")

# Highlight differences in red

pixels = diff.load()

for y in range(diff.height):

for x in range(diff.width):

r, g, b = pixels[x, y]

if r + g + b > 50:

pixels[x, y] = (255, 0, 0)

return diff

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

# Compare PDFs

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

def compare_pdfs(pdf1, pdf2):

doc1 = fitz.open(pdf1)

doc2 = fitz.open(pdf2)

total_pages = max(len(doc1), len(doc2))

for page in range(total_pages):

print(f"🔍 Comparing page {page + 1}")

# ----- TEXT COMPARISON -----

text1 = extract_text(pdf1, page)

text2 = extract_text(pdf2, page)

diff_text = text_diff(text1, text2)

text_output = os.path.join(

OUTPUT_DIR, f"page_{page + 1}_text_diff.txt"

)

with open(text_output, "w", encoding="utf-8") as f:

f.write(diff_text)

# ----- IMAGE COMPARISON -----

try:

img1 = render_page_image(pdf1, page)

img2 = render_page_image(pdf2, page)

diff_img = image_diff(img1, img2)

img_output = os.path.join(

OUTPUT_DIR, f"page_{page + 1}_image_diff.png"

)

diff_img.save(img_output)

except Exception as e:

print(f"⚠️ Image diff skipped for page {page + 1}: {e}")

print("\n✅ PDF comparison complete.")

print(f"📁 Results saved in: {OUTPUT_DIR}")

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

# RUN

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

if __name__ == "__main__":

pdf_a = input("Enter first PDF path: ").strip()

pdf_b = input("Enter second PDF path: ").strip()

compare_pdfs(pdf_a, pdf_b)

Smart Screen Recorder with Auto-Pause

import cv2

import numpy as np

import mss

import time

from datetime import datetime

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

# CONFIGURATION

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

FPS = 10

MOTION_THRESHOLD = 50000 # Higher = less sensitive

NO_MOTION_TIME = 2 # seconds to auto pause

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

# Setup screen capture

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

sct = mss.mss()

monitor = sct.monitors[1] # Primary screen

width = monitor["width"]

height = monitor["height"]

fourcc = cv2.VideoWriter_fourcc(*"XVID")

output_file = f"screen_record_{datetime.now().strftime('%Y%m%d_%H%M%S')}.avi"

out = cv2.VideoWriter(output_file, fourcc, FPS, (width, height))

print("🎥 Screen recording started...")

print("🟢 Recording will pause automatically when screen is idle.")

print("🔴 Press 'Q' to stop recording.\n")

prev_frame = None

last_motion_time = time.time()

recording = True

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

# Recording Loop

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

while True:

img = np.array(sct.grab(monitor))

frame = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)

gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

gray = cv2.GaussianBlur(gray, (21, 21), 0)

if prev_frame is None:

prev_frame = gray

continue

# Frame difference

frame_diff = cv2.absdiff(prev_frame, gray)

thresh = cv2.threshold(frame_diff, 25, 255, cv2.THRESH_BINARY)[1]

motion_score = np.sum(thresh)

if motion_score > MOTION_THRESHOLD:

last_motion_time = time.time()

recording = True

else:

if time.time() - last_motion_time > NO_MOTION_TIME:

recording = False

# Write frame only if motion exists

if recording:

out.write(frame)

status_text = "RECORDING"

color = (0, 255, 0)

else:

status_text = "PAUSED (No Motion)"

color = (0, 0, 255)

# Overlay status

cv2.putText(

frame,

status_text,

(20, 40),

cv2.FONT_HERSHEY_SIMPLEX,

color,

)

cv2.imshow("Smart Screen Recorder", frame)

prev_frame = gray

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

break

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

# Cleanup

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

out.release()

cv2.destroyAllWindows()

print(f"\n✅ Recording saved as: {output_file}")

Daily Habit Forecasting Using Time-Series

import pandas as pd

import matplotlib.pyplot as plt

from statsmodels.tsa.holtwinters import ExponentialSmoothing

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

# Load & Prepare Data

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

def load_habit_data(csv_path, habit_name):

df = pd.read_csv(csv_path)

df["date"] = pd.to_datetime(df["date"])

habit_df = df[df["habit"] == habit_name]

habit_df = habit_df.sort_values("date")

habit_df.set_index("date", inplace=True)

ts = habit_df["completed"]

return ts

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

# Forecast Habit Completion

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

def forecast_habit(ts, days=7):

model = ExponentialSmoothing(

ts,

trend="add",

seasonal=None,

initialization_method="estimated"

)

fitted_model = model.fit()

forecast = fitted_model.forecast(days)

return fitted_model, forecast

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

# Risk Analysis

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

def habit_risk_score(forecast):

avg_completion = forecast.mean()

if avg_completion < 0.4:

return "🚨 High Risk (likely to break)"

elif avg_completion < 0.7:

return "⚠️ Medium Risk"

else:

return "✅ Low Risk (stable habit)"

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

# Visualization

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

def plot_forecast(ts, forecast, habit_name):

plt.figure(figsize=(10, 5))

plt.plot(ts.index, ts.values, label="Past Completion", marker="o")

plt.plot(forecast.index, forecast.values, label="Forecast", linestyle="--", marker="x")

plt.ylim(-0.1, 1.1)

plt.ylabel("Habit Completed (1=yes, 0=no)")

plt.title(f"Habit Forecast: {habit_name}")

plt.legend()

plt.grid(True)

plt.show()

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

# MAIN

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

if __name__ == "__main__":

csv_file = input("Enter CSV file path: ").strip()

habit = input("Enter habit name (case-sensitive): ").strip()

ts = load_habit_data(csv_file, habit)

model, forecast = forecast_habit(ts, days=7)

risk = habit_risk_score(forecast)

print("\n📊 HABIT FORECAST REPORT")

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

print(f"Habit: {habit}")

print(f"Next 7-day average completion: {forecast.mean():.2f}")

print(f"Risk Level: {risk}")

plot_forecast(ts, forecast, habit)

Local Password Strength Analyzer

import tkinter as tk

from tkinter import ttk

import math

import re

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

# Heuristics & helpers

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

COMMON_PASSWORDS = {

"password", "123456", "123456789", "qwerty", "abc123",

"letmein", "welcome", "admin", "iloveyou", "monkey"

}

SEQUENCES = [

"abcdefghijklmnopqrstuvwxyz",

"ABCDEFGHIJKLMNOPQRSTUVWXYZ",

"0123456789",

"qwertyuiop", "asdfghjkl", "zxcvbnm"

]

def shannon_entropy(password: str) -> float:

"""Approximate entropy based on character sets used."""

pool = 0

if re.search(r"[a-z]", password): pool += 26

if re.search(r"[A-Z]", password): pool += 26

if re.search(r"\d", password): pool += 10

if re.search(r"[^\w\s]", password): pool += 32 # symbols

if pool == 0:

return 0.0

return len(password) * math.log2(pool)

def has_repeats(password: str) -> bool:

return bool(re.search(r"(.)\1{2,}", password)) # aaa, 111

def has_sequence(password: str) -> bool:

p = password

for seq in SEQUENCES:

for i in range(len(seq) - 3):

if seq[i:i+4] in p:

return True

return False

def keyboard_walk(password: str) -> bool:

walks = ["qwerty", "asdf", "zxcv", "poiuy", "lkjhg", "mnbv"]

p = password.lower()

return any(w in p for w in walks)

def analyze_password(password: str):

issues = []

score = 0

# Length

if len(password) < 8:

issues.append("Too short (minimum 8 characters).")

else:

score += min(20, (len(password) - 7) * 3)

# Character classes

classes = 0

classes += bool(re.search(r"[a-z]", password))

classes += bool(re.search(r"[A-Z]", password))

classes += bool(re.search(r"\d", password))

classes += bool(re.search(r"[^\w\s]", password))

score += classes * 10

if classes < 3:

issues.append("Use at least 3 character types (upper/lower/digits/symbols).")

# Entropy

ent = shannon_entropy(password)

score += min(30, int(ent / 3)) # cap contribution

if ent < 40:

issues.append("Low entropy. Add length and variety.")

# Patterns

if password.lower() in COMMON_PASSWORDS:

issues.append("Common password detected.")

score -= 30

if has_repeats(password):

issues.append("Repeated characters detected (e.g., 'aaa').")

score -= 10

if has_sequence(password):

issues.append("Sequential pattern detected (e.g., 'abcd', '1234').")

score -= 10

if keyboard_walk(password):

issues.append("Keyboard pattern detected (e.g., 'qwerty').")

score -= 10

score = max(0, min(100, score))

if score >= 80:

verdict = "Strong"

elif score >= 60:

verdict = "Good"

elif score >= 40:

verdict = "Weak"

else:

verdict = "Very Weak"

return {

"score": score,

"verdict": verdict,

"entropy": round(ent, 1),

"issues": issues

}

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

# GUI

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

class App(tk.Tk):

def __init__(self):

super().__init__()

self.title("Local Password Strength Analyzer")

self.geometry("520x420")

self.resizable(False, False)

ttk.Label(self, text="Enter Password:", font=("Arial", 12)).pack(pady=10)

self.pw = ttk.Entry(self, show="*", width=40)

self.pw.pack()

self.show_var = tk.BooleanVar(value=False)

ttk.Checkbutton(self, text="Show password", variable=self.show_var,

command=self.toggle_show).pack(pady=5)

ttk.Button(self, text="Analyze", command=self.run).pack(pady=10)

self.score_lbl = ttk.Label(self, text="Score: —", font=("Arial", 12, "bold"))

self.score_lbl.pack()

self.ent_lbl = ttk.Label(self, text="Entropy: — bits")

self.ent_lbl.pack(pady=5)

self.verdict_lbl = ttk.Label(self, text="Verdict: —", font=("Arial", 12))

self.verdict_lbl.pack(pady=5)

ttk.Label(self, text="Feedback:", font=("Arial", 11, "bold")).pack(pady=8)

self.feedback = tk.Text(self, height=8, width=60, wrap="word")

self.feedback.pack(padx=10)

def toggle_show(self):

self.pw.config(show="" if self.show_var.get() else "*")

def run(self):

pwd = self.pw.get()

res = analyze_password(pwd)

self.score_lbl.config(text=f"Score: {res['score']}/100")

self.ent_lbl.config(text=f"Entropy: {res['entropy']} bits")

self.verdict_lbl.config(text=f"Verdict: {res['verdict']}")

self.feedback.delete("1.0", "end")

if res["issues"]:

for i in res["issues"]:

self.feedback.insert("end", f"• {i}\n")

else:

self.feedback.insert("end", "No issues found. Great password!")

if __name__ == "__main__":

App().mainloop()

Blog Pages