Python for Engineers

Simple Chatbot with Pattern Matching

import re

import random

import json

from datetime import datetime

from pathlib import Path

# ============================================================

# KNOWLEDGE BASE — Patterns & Responses

# ============================================================

PATTERNS = [

# ---------- Greetings ----------

{

"tag": "greeting",

"patterns": [

"responses": [

"Hey there! How can I help you today?",

"Hello! Great to see you. What's on your mind?",

"Hi! I'm ready to chat. What can I do for you?",

"Howdy! Ask me anything!"

]

# ---------- How are you ----------

{

"tag": "how_are_you",

"patterns": [

r"\b(how are you|how are you doing|how do you do|how's it going|are you ok)\b"

"responses": [

"I'm doing great, thanks for asking! How about you?",

"Running at full capacity! What can I help with?",

"All systems go! What's up?",

"Fantastic! Ready to chat. How are YOU doing?"

]

# ---------- Name ----------

{

"tag": "name",

"patterns": [

r"\b(what is your name|what's your name|who are you|tell me your name)\b"

"responses": [

"I'm PyBot - your Python-powered chatbot!",

"My name is PyBot! Nice to meet you.",

"Call me PyBot. I'm a rule-based chatbot built in Python."

]

# ---------- Creator ----------

{

"tag": "creator",

"patterns": [

r"\b(who made you|who created you|who built you|who programmed you|who is your creator)\b"

"responses": [

"I was built using Python with regex pattern matching!",

"A Python developer created me using re, random, and json.",

"I'm powered by Python! Check out pythonforengineers.in for the code."

]

# ---------- Time ----------

{

"tag": "time",

"patterns": [

r"\b(what time is it|current time|tell me the time|what's the time|what is the time)\b"

"responses": ["__TIME__"]

# ---------- Date ----------

{

"tag": "date",

"patterns": [

r"\b(what is today's date|what's today's date|what day is it|today's date|current date)\b"

"responses": ["__DATE__"]

# ---------- Weather ----------

{

"tag": "weather",

"patterns": [

"responses": [

"I can't check live weather, but try weather.com or Google Weather!",

"I don't have internet access, but a quick Google search will give you the forecast!",

]

# ---------- Math ----------

{

"tag": "math",

"patterns": [

r"(\d+)\s*[\+\-\*\/]\s*(\d+)"

"responses": ["__MATH__"]

# ---------- Jokes ----------

{

"tag": "joke",

"patterns": [

r"\b(tell me a joke|joke|make me laugh|say something funny|funny)\b"

"responses": [

"Why do Python programmers prefer dark mode? Because light attracts bugs!",

"Why was the developer broke? Because he used up all his cache!",

"What do you call a bear with no teeth? A gummy bear!",

"Why did the programmer quit? Because he didn't get arrays (a raise)!",

"Debugging: Being the detective in a crime movie where you're also the murderer."

]

# ---------- Python ----------

{

"tag": "python",

"patterns": [

"responses": [

"Python is one of the most popular languages! Great for automation, AI, web dev and more.",

"Python is beginner-friendly yet powerful. What would you like to build?",

"Love Python! Check out pythonforengineers.in for cool Python programs."

]

# ---------- Help ----------

{

"tag": "help",

"patterns": [

r"\b(help|what can you do|your features|capabilities|what do you know)\b"

"responses": [

"I can:\n * Chat with you\n * Tell jokes\n * Answer basic questions\n * Do simple math\n * Tell time and date\n * Remember your name\n\nJust type naturally!"

]

# ---------- Name capture ----------

{

"tag": "user_name",

"patterns": [

r"\bmy name is (\w+)\b",

r"\bi am (\w+)\b",

r"\bcall me (\w+)\b"

"responses": ["__REMEMBER_NAME__"]

# ---------- Goodbye ----------

{

"tag": "goodbye",

"patterns": [

"responses": [

"Goodbye! Have a great day!",

"See you later! It was nice chatting!",

"Take care! Come back anytime.",

"Bye! Keep coding!"

]

# ---------- Thanks ----------

{

"tag": "thanks",

"patterns": [

"responses": [

"You're welcome!",

"Happy to help!",

"Anytime! That's what I'm here for.",

"No problem at all!"

]

# ---------- Age ----------

{

"tag": "age",

"patterns": [

r"\b(how old are you|what's your age|what is your age|when were you born)\b"

"responses": [

"I was born the moment someone ran this Python script! So pretty young.",

"Age is just a number, but I'm freshly compiled!"

]

# ---------- Favorites ----------

{

"tag": "favorites",

"patterns": [

r"\b(favorite language|favorite food|favorite color|what do you like)\b"

"responses": [

"My favorite language is obviously Python!",

"I like Python, clean code, and well-commented scripts! What about you?",

]

# ---------- Meaning of life ----------

{

"tag": "meaning",

"patterns": [

r"\b(meaning of life|purpose of life|why are we here|42)\b"

"responses": [

"42. Obviously.",

"The meaning of life is to write clean, well-documented Python code. At least, that's my belief.",

]

# ============================================================

# SPECIAL RESPONSE HANDLERS

# ============================================================

def handle_special(response, user_input, memory):

if response == "__TIME__":

now = datetime.now().strftime("%I:%M %p")

return f"The current time is {now}"

if response == "__DATE__":

today = datetime.now().strftime("%A, %d %B %Y")

return f"Today is {today}"

if response == "__MATH__":

try:

expr = re.search(r"(\d+\s*[\+\-\*\/]\s*\d+)", user_input)

if expr:

result = eval(expr.group(0))

return f"The answer is: {result}"

except:

return "Hmm, I couldn't calculate that. Try something like: 5 + 3"

if response == "__REMEMBER_NAME__":

name_match = re.search(

r"\b(?:my name is|i am|call me)\s+(\w+)\b",

user_input, re.IGNORECASE

)

if name_match:

name = name_match.group(1).capitalize()

memory["user_name"] = name

return f"Nice to meet you, {name}! I'll remember that."

return "Nice name! What's it again?"

return response

# ============================================================

# MATCH USER INPUT TO PATTERN

# ============================================================

def get_response(user_input, memory):

text = user_input.lower().strip()

for rule in PATTERNS:

for pattern in rule["patterns"]:

if re.search(pattern, text, re.IGNORECASE):

response = random.choice(rule["responses"])

response = handle_special(response, text, memory)

# Occasionally personalize with name if known

if "user_name" in memory and random.random() < 0.3:

response = f"{memory['user_name']}, " + response[0].lower() + response[1:]

return response

# Fallback

fallbacks = [

"Hmm, I'm not sure I understand. Could you rephrase that?",

"Interesting! Tell me more.",

"I don't have an answer for that yet, but I'm learning!",

"That's a good one! I'm still a work in progress.",

"Could you ask that differently? I want to help!",

"I'm not sure about that. Try asking me something else!"

]

return random.choice(fallbacks)

# ============================================================

# SAVE CHAT HISTORY

# ============================================================

def save_chat_history(history, session_start):

filename = f"chat_history_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"

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

json.dump({

"session": session_start,

"messages": history

}, f, indent=2, ensure_ascii=False)

print(f"\n Chat saved to {filename}")

# ============================================================

# MAIN CHAT LOOP

# ============================================================

def main():

print("\n" + "="*55)

print(" PYBOT - Pattern Matching Chatbot")

print("="*55)

print("\n Type 'help' - see what I can do")

print(" Type 'history' - save chat log to file")

print(" Type 'bye' - exit\n")

print("-"*55)

memory = {}

history = []

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

while True:

try:

user_input = input("\n You: ").strip()

except (EOFError, KeyboardInterrupt):

print("\n\n Interrupted. Goodbye!")

break

if not user_input:

continue

# Save history command

if user_input.lower() == "history":

save_chat_history(history, session_start)

continue

# Get and print response

response = get_response(user_input, memory)

print(f"\n PyBot: {response}")

# Log conversation

history.append({

"user": user_input,

"bot": response,

"time": datetime.now().strftime("%H:%M:%S")

})

# Exit trigger

if any(re.search(p, user_input.lower())

for p in [r"\b(bye|goodbye|quit|exit)\b"]):

break

print("\n" + "="*55)

print(" Thanks for chatting! Session ended.")

print("="*55 + "\n")

# ============================================================

# RUN

# ============================================================

if __name__ == "__main__":

main()

Website Uptime Monitor

import requests

import json

import os

import time

import threading

import smtplib

from datetime import datetime

from pathlib import Path

from email.mime.text import MIMEText

from email.mime.multipart import MIMEMultipart

from collections import defaultdict

# ============================================================

# CONFIGURATION

# ============================================================

SITES_FILE = "monitored_sites.json"

LOG_FILE = "uptime_log.json"

CONFIG_FILE = "uptime_config.json"

CHECK_TIMEOUT = 10 # seconds before a request is considered failed

DEFAULT_INTERVAL = 60 # seconds between checks

# ============================================================

# LOAD & SAVE HELPERS

# ============================================================

def load_json(filepath, default):

if Path(filepath).exists():

try:

with open(filepath, "r") as f:

return json.load(f)

except:

return default

def save_json(filepath, data):

with open(filepath, "w") as f:

json.dump(data, f, indent=2)

# ============================================================

# CHECK A SINGLE WEBSITE

# ============================================================

def check_site(url):

"""

Ping a URL and return a result dict:

status, response_time_ms, status_code, error

"""

start = time.time()

try:

response = requests.get(url, timeout=CHECK_TIMEOUT,

allow_redirects=True,

headers={"User-Agent": "UptimeMonitor/1.0"})

elapsed = round((time.time() - start) * 1000, 1)

is_up = response.status_code < 400

return {

"url": url,

"status": "UP" if is_up else "DOWN",

"status_code": response.status_code,

"response_time_ms": elapsed,

"error": None,

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

}

except requests.exceptions.ConnectionError:

return {

"url": url,

"status": "DOWN",

"status_code": None,

"response_time_ms": None,

"error": "Connection refused",

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

}

except requests.exceptions.Timeout:

return {

"url": url,

"status": "DOWN",

"status_code": None,

"response_time_ms": None,

"error": f"Timeout after {CHECK_TIMEOUT}s",

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

}

except Exception as e:

return {

"url": url,

"status": "DOWN",

"status_code": None,

"response_time_ms": None,

"error": str(e),

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

}

# ============================================================

# SEND EMAIL ALERT

# ============================================================

def send_alert(config, subject, body):

try:

msg = MIMEMultipart()

msg["From"] = config["email"]

msg["To"] = config["alert_email"]

msg["Subject"] = subject

msg.attach(MIMEText(body, "plain"))

server = smtplib.SMTP(config["smtp_host"], config["smtp_port"])

server.starttls()

server.login(config["email"], config["password"])

server.sendmail(config["email"], config["alert_email"], msg.as_string())

server.quit()

print(f"\n Alert sent to {config['alert_email']}")

except Exception as e:

print(f"\n ⚠ Email alert failed: {e}")

# ============================================================

# UPTIME MONITOR CLASS

# ============================================================

class UptimeMonitor:

def __init__(self):

self.sites = load_json(SITES_FILE, [])

self.log = load_json(LOG_FILE, {})

self.config = load_json(CONFIG_FILE, {})

self.running = False

self.last_status = {} # url -> "UP" or "DOWN"

self.downtime_start = {} # url -> datetime when it went down

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

# Site Management

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

def add_site(self, url, name=None, interval=DEFAULT_INTERVAL):

# Normalize URL

if not url.startswith("http"):

url = "https://" + url

# Check duplicates

if any(s["url"] == url for s in self.sites):

print(f"\n ⚠ Already monitoring: {url}")

return

site = {

"url": url,

"name": name or url,

"interval": interval,

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

}

self.sites.append(site)

save_json(SITES_FILE, self.sites)

print(f"\n Added: {site['name']} ({url})")

def remove_site(self, index):

if 0 <= index < len(self.sites):

removed = self.sites.pop(index)

save_json(SITES_FILE, self.sites)

print(f"\n 🗑 Removed: {removed['name']}")

else:

print("\n Invalid index.")

def list_sites(self):

if not self.sites:

print("\n 📭 No sites being monitored.")

return

print("\n" + "="*60)

print(f" {'#':<4} {'NAME':<20} {'URL':<30} {'INTERVAL'}")

print(" " + "-"*56)

for i, s in enumerate(self.sites, 1):

status_icon = "🟢" if self.last_status.get(s["url"]) == "UP" else \

"🔴" if self.last_status.get(s["url"]) == "DOWN" else "⚪"

print(f" {status_icon} {i:<3} {s['name']:<20} {s['url']:<30} every {s['interval']}s")

print("="*60)

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

# Manual Check (all sites at once)

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

def check_all_now(self):

if not self.sites:

print("\n 📭 No sites to check.")

return

print(f"\n Checking {len(self.sites)} site(s)...\n")

print(f" {'STATUS':<8} {'SITE':<25} {'CODE':<8} {'RESPONSE':<14} {'TIME'}")

print(" " + "-"*65)

for site in self.sites:

result = check_site(site["url"])

self._record_result(site["url"], result)

icon = " UP " if result["status"] == "UP" else " DOWN"

code = str(result["status_code"]) if result["status_code"] else "—"

rt = f"{result['response_time_ms']}ms" if result["response_time_ms"] else "—"

error = f" ⚠ {result['error']}" if result["error"] else ""

print(f" {icon} {site['name']:<25} {code:<8} {rt:<14} {result['checked_at']}{error}")

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

# Continuous Monitor Loop (runs in thread)

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

def _monitor_loop(self):

print(" Monitor running in background...")

self.running = True

counters = {s["url"]: 0 for s in self.sites}

while self.running:

for site in self.sites:

url = site["url"]

interval = site.get("interval", DEFAULT_INTERVAL)

counters[url] = counters.get(url, 0) + 1

if counters[url] >= interval:

counters[url] = 0

result = check_site(url)

prev = self.last_status.get(url)

self._record_result(url, result)

# Status changed → alert

if prev and prev != result["status"]:

if result["status"] == "DOWN":

self.downtime_start[url] = datetime.now()

msg = (f" DOWN: {site['name']}\n"

f"URL: {url}\n"

f"Error: {result['error']}\n"

f"Time: {result['checked_at']}")

print(f"\n ALERT: {site['name']} is DOWN!")

print(" > ", end="", flush=True)

if self.config:

send_alert(self.config,

f" DOWN: {site['name']}",

msg)

else:

downtime = ""

if url in self.downtime_start:

delta = datetime.now() - self.downtime_start[url]

mins = int(delta.total_seconds() // 60)

secs = int(delta.total_seconds() % 60)

downtime = f" (was down for {mins}m {secs}s)"

del self.downtime_start[url]

print(f"\n RECOVERED: {site['name']}{downtime}")

print(" > ", end="", flush=True)

if self.config:

send_alert(self.config,

f" Recovered: {site['name']}",

f"{site['name']} is back UP{downtime}\nURL: {url}\nTime: {result['checked_at']}")

self.last_status[url] = result["status"]

time.sleep(1)

def start_monitoring(self):

if not self.sites:

print("\n No sites added yet.")

return

t = threading.Thread(target=self._monitor_loop, daemon=True)

t.start()

def stop_monitoring(self):

self.running = False

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

# Record Result to Log

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

def _record_result(self, url, result):

if url not in self.log:

self.log[url] = []

self.log[url].append(result)

# Keep last 500 entries per site

if len(self.log[url]) > 500:

self.log[url] = self.log[url][-500:]

save_json(LOG_FILE, self.log)

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

# Uptime Stats Report

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

def show_stats(self):

if not self.log:

print("\n 📭 No data logged yet. Run a check first.")

return

print("\n" + "="*60)

print(" UPTIME STATISTICS")

print("="*60)

for site in self.sites:

url = site["url"]

records = self.log.get(url, [])

if not records:

continue

total = len(records)

up_count = sum(1 for r in records if r["status"] == "UP")

uptime = (up_count / total) * 100

# Avg response time

times = [r["response_time_ms"] for r in records if r["response_time_ms"]]

avg_rt = round(sum(times) / len(times), 1) if times else None

# Last checked

last = records[-1]

status_icon = "🟢" if last["status"] == "UP" else "🔴"

print(f"\n {status_icon} {site['name']}")

print(f" URL : {url}")

print(f" Uptime : {uptime:.2f}% ({up_count}/{total} checks passed)")

print(f" Avg Response: {avg_rt}ms" if avg_rt else " Avg Response: —")

print(f" Last Check : {last['checked_at']} [{last['status']}]")

if last.get("error"):

print(f" Last Error : {last['error']}")

print("="*60)

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

# Setup Email Alerts

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

def setup_alerts(self):

print("\n" + "="*55)

print(" EMAIL ALERT SETUP")

print("="*55)

print("\n Providers: Gmail (smtp.gmail.com:587) | Outlook (smtp.office365.com:587)")

smtp_host = input("\n SMTP Host: ").strip()

smtp_port = int(input(" SMTP Port: ").strip() or 587)

email = input(" Your email: ").strip()

password = input(" App password: ").strip()

alert_email = input(" Send alerts to (email): ").strip()

self.config = {

"smtp_host": smtp_host,

"smtp_port": smtp_port,

"email": email,

"password": password,

"alert_email": alert_email

}

save_json(CONFIG_FILE, self.config)

print("\n ✅ Alert config saved.")

# ============================================================

# MAIN MENU

# ============================================================

def print_menu(monitor):

status = " Running" if monitor.running else "⚫ Stopped"

print("\n" + "-"*45)

print(f" WEBSITE UPTIME MONITOR [{status}]")

print("-"*45)

print(" 1. Add website to monitor")

print(" 2. Remove website")

print(" 3. List monitored sites")

print(" 4. Check all sites NOW")

print(" 5. Start continuous monitor (background)")

print(" 6. View uptime statistics")

print(" 7. Setup email alerts")

print(" 0. Exit")

print("-"*45)

def main():

print("\n" + "="*55)

print(" WEBSITE UPTIME MONITOR")

print("="*55)

print(f"\n Check timeout : {CHECK_TIMEOUT}s")

print(f" Default interval: every {DEFAULT_INTERVAL}s")

print(f" Log file : {LOG_FILE}")

monitor = UptimeMonitor()

if monitor.sites:

print(f"\n Loaded {len(monitor.sites)} monitored site(s).")

if monitor.config:

print(f" Alerts configured for: {monitor.config.get('alert_email','')}")

while True:

print_menu(monitor)

choice = input(" > ").strip()

if choice == "1":

url = input("\n Website URL (e.g. google.com): ").strip()

name = input(" Display name (or Enter to use URL): ").strip() or None

interval = input(f" Check interval in seconds (default {DEFAULT_INTERVAL}): ").strip()

interval = int(interval) if interval.isdigit() else DEFAULT_INTERVAL

monitor.add_site(url, name, interval)

elif choice == "2":

monitor.list_sites()

if monitor.sites:

try:

idx = int(input("\n Enter site number to remove: ").strip()) - 1

monitor.remove_site(idx)

except ValueError:

print(" Invalid input.")

elif choice == "3":

monitor.list_sites()

elif choice == "4":

monitor.check_all_now()

elif choice == "5":

if monitor.running:

print("\n Monitor is already running.")

else:

monitor.start_monitoring()

print(f"\n Continuous monitor started!")

print(f" Alerts will print here. Keep this window open.")

elif choice == "6":

monitor.show_stats()

elif choice == "7":

monitor.setup_alerts()

elif choice == "0":

monitor.stop_monitoring()

print("\n Goodbye!\n")

break

else:

print(" Invalid choice.")

# ============================================================

# RUN

# ============================================================

if __name__ == "__main__":

main()

Screen Time Tracker

import psutil

import json

import time

import os

import threading

from datetime import datetime, date

from pathlib import Path

from collections import defaultdict

# ============================================================

# CONFIGURATION

# ============================================================

DATA_FILE = "screen_time_data.json"

POLL_INTERVAL = 3 # seconds between process checks

DAILY_LIMIT = {} # optional per-app daily limits in minutes

# ============================================================

# LOAD & SAVE DATA

# ============================================================

def load_data():

if Path(DATA_FILE).exists():

try:

with open(DATA_FILE, "r") as f:

return json.load(f)

except:

return {}

def save_data(data):

with open(DATA_FILE, "w") as f:

json.dump(data, f, indent=2)

# ============================================================

# GET ACTIVE PROCESSES

# ============================================================

def get_running_apps():

"""Return a set of currently running process names (lowercased)."""

apps = set()

for proc in psutil.process_iter(["name", "status"]):

try:

if proc.info["status"] == psutil.STATUS_RUNNING:

name = proc.info["name"].lower().replace(".exe", "")

apps.add(name)

except (psutil.NoSuchProcess, psutil.AccessDenied):

pass

return apps

def get_all_processes():

"""Return all running process names (including sleeping/idle)."""

apps = set()

for proc in psutil.process_iter(["name"]):

try:

name = proc.info["name"].lower().replace(".exe", "")

apps.add(name)

except (psutil.NoSuchProcess, psutil.AccessDenied):

pass

return apps

# ============================================================

# SCREEN TIME TRACKER CLASS

# ============================================================

class ScreenTimeTracker:

def __init__(self):

self.data = load_data()

self.tracking = {} # app -> start_time (if currently active)

self.watch_list = set() # apps to specifically watch

self.running = False

self.today = str(date.today())

self.limits = {} # app -> minutes limit

self.alerted = set() # apps already alerted today

# Ensure today's entry exists

if self.today not in self.data:

self.data[self.today] = {}

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

# Add / Remove from Watch List

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

def add_to_watchlist(self, app_name):

name = app_name.lower().replace(".exe", "")

self.watch_list.add(name)

print(f"\n Added to watchlist: {name}")

def remove_from_watchlist(self, app_name):

name = app_name.lower().replace(".exe", "")

self.watch_list.discard(name)

print(f"\n Removed from watchlist: {name}")

def set_limit(self, app_name, minutes):

name = app_name.lower().replace(".exe", "")

self.limits[name] = minutes

print(f"\n Limit set: {name} → {minutes} min/day")

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

# Core Tracking Loop

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

def track(self):

print("\n Tracker running in background...")

self.running = True

while self.running:

now = datetime.now()

today_str = str(date.today())

# New day reset

if today_str != self.today:

self.today = today_str

self.alerted = set()

if self.today not in self.data:

self.data[self.today] = {}

# Get active apps

if self.watch_list:

active_now = get_all_processes() & self.watch_list

else:

active_now = get_running_apps()

# Apps that just started

for app in active_now:

if app not in self.tracking:

self.tracking[app] = now

# Apps that just stopped

stopped = set(self.tracking.keys()) - active_now

for app in stopped:

elapsed = (now - self.tracking[app]).total_seconds()

self._add_time(app, elapsed)

del self.tracking[app]

# Check limits

for app in active_now:

total_mins = self._get_today_minutes(app)

if app in self.limits and total_mins >= self.limits[app]:

if app not in self.alerted:

print(f"\n ⚠ LIMIT REACHED: [{app}] — {total_mins:.1f} min used (limit: {self.limits[app]} min)")

print(" > ", end="", flush=True)

self.alerted.add(app)

save_data(self.data)

time.sleep(POLL_INTERVAL)

# Final flush — save any still-running apps

now = datetime.now()

for app, start in self.tracking.items():

elapsed = (now - start).total_seconds()

self._add_time(app, elapsed)

save_data(self.data)

def stop(self):

self.running = False

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

# Time Helpers

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

def _add_time(self, app, seconds):

today = self.today

if today not in self.data:

self.data[today] = {}

self.data[today][app] = self.data[today].get(app, 0) + seconds

def _get_today_minutes(self, app):

return self.data.get(self.today, {}).get(app, 0) / 60

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

# Reports

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

def report_today(self):

today_data = self.data.get(self.today, {})

# Add currently running session time (not yet saved)

now = datetime.now()

live = {}

for app, start in self.tracking.items():

live[app] = (now - start).total_seconds()

merged = dict(today_data)

for app, secs in live.items():

merged[app] = merged.get(app, 0) + secs

if not merged:

print("\n No screen time data for today yet.")

return

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

print("\n" + "="*55)

print(f" SCREEN TIME REPORT — {self.today}")

print("="*55)

print(f"\n {'APP':<25} {'TIME':>12} {'LIMIT':>10}")

print(" " + "-"*50)

total_secs = 0

for app, secs in sorted_apps:

h, m, s = _hms(secs)

time_str = f"{h}h {m:02d}m {s:02d}s" if h else f"{m}m {s:02d}s"

limit_str = f"{self.limits[app]} min" if app in self.limits else "—"

bar = _bar(secs, max(v for _, v in sorted_apps))

print(f" {app:<25} {time_str:>12} {limit_str:>10} {bar}")

total_secs += secs

print(" " + "-"*50)

h, m, s = _hms(total_secs)

print(f" {'TOTAL':<25} {h}h {m:02d}m {s:02d}s")

print("="*55)

def report_week(self):

print("\n" + "="*55)

print(" WEEKLY SCREEN TIME SUMMARY")

print("="*55)

app_totals = defaultdict(float)

day_totals = {}

for day_str, apps in sorted(self.data.items())[-7:]:

day_total = sum(apps.values())

day_totals[day_str] = day_total

for app, secs in apps.items():

app_totals[app] += secs

print("\n Daily totals:")

for day, secs in day_totals.items():

h, m, _ = _hms(secs)

bar = _bar(secs, max(day_totals.values()) if day_totals else 1)

print(f" {day} {h}h {m:02d}m {bar}")

print("\n Top apps this week:")

top = sorted(app_totals.items(), key=lambda x: x[1], reverse=True)[:10]

for app, secs in top:

h, m, _ = _hms(secs)

print(f" • {app:<25} {h}h {m:02d}m")

print("="*55)

def list_watchlist(self):

print("\n 👁 Current watchlist:")

if self.watch_list:

for app in sorted(self.watch_list):

limit = f" (limit: {self.limits[app]} min)" if app in self.limits else ""

print(f" • {app}{limit}")

else:

print(" (empty — tracking ALL running processes)")

def show_running_now(self):

apps = get_all_processes()

print(f"\n 🖥 Currently running processes ({len(apps)}):")

for i, app in enumerate(sorted(apps), 1):

active = "" if app in self.tracking else " "

print(f" {active} {app}")

if i % 30 == 0:

cont = input(" ... show more? (y/n): ").strip().lower()

if cont != "y":

break

# ============================================================

# HELPERS

# ============================================================

def _hms(seconds):

seconds = int(seconds)

h = seconds // 3600

m = (seconds % 3600) // 60

s = seconds % 60

return h, m, s

def _bar(value, max_value, width=10):

if max_value == 0:

return ""

filled = int((value / max_value) * width)

return "█" * filled + "░" * (width - filled)

# ============================================================

# MAIN MENU

# ============================================================

def print_menu():

print("\n" + "-"*45)

print(" SCREEN TIME TRACKER")

print("-"*45)

print(" 1. Start tracking (background)")

print(" 2. Today's report")

print(" 3. Weekly summary")

print(" 4. Manage watchlist")

print(" 5. Set app time limit")

print(" 6. Show all running processes")

print(" 0. Stop & Exit")

print("-"*45)

def manage_watchlist(tracker):

print("\n Watchlist options:")

print(" 1. Add app to watchlist")

print(" 2. Remove app from watchlist")

print(" 3. View current watchlist")

sub = input(" Choice: ").strip()

if sub == "1":

app = input(" App name (e.g. chrome, code, vlc): ").strip()

tracker.add_to_watchlist(app)

elif sub == "2":

app = input(" App name to remove: ").strip()

tracker.remove_from_watchlist(app)

elif sub == "3":

tracker.list_watchlist()

def main():

print("\n" + "="*55)

print(" SCREEN TIME TRACKER")

print("="*55)

print(f"\n Data file : {DATA_FILE}")

print(f" Poll interval: every {POLL_INTERVAL} seconds")

print("\n Tip: Add specific apps to watchlist for focused tracking.")

print(" Or track ALL processes without a watchlist.")

tracker = ScreenTimeTracker()

tracker_thread = None

while True:

print_menu()

choice = input(" > ").strip()

if choice == "1":

if tracker_thread and tracker_thread.is_alive():

print("\n Tracker is already running.")

else:

tracker_thread = threading.Thread(target=tracker.track, daemon=True)

tracker_thread.start()

elif choice == "2":

tracker.report_today()

elif choice == "3":

tracker.report_week()

elif choice == "4":

manage_watchlist(tracker)

elif choice == "5":

app = input("\n App name: ").strip()

mins = int(input(" Daily limit (minutes): ").strip())

tracker.set_limit(app, mins)

elif choice == "6":

tracker.show_running_now()

elif choice == "0":

print("\n Stopping tracker...")

tracker.stop()

if tracker_thread:

tracker_thread.join(timeout=5)

print(" Data saved.")

print(" Goodbye!\n")

break

else:

print(" Invalid choice.")

# ============================================================

# RUN

# ============================================================

if __name__ == "__main__":

main()

Auto Email Scheduler

import smtplib

import schedule

import json

import os

import time

import threading

from email.mime.text import MIMEText

from email.mime.multipart import MIMEMultipart

from email.mime.base import MIMEBase

from email import encoders

from datetime import datetime, timedelta

from pathlib import Path

# ============================================================

# CONFIGURATION FILE

# ============================================================

CONFIG_FILE = "email_config.json"

SCHEDULE_FILE = "email_schedule.json"

# ============================================================

# SAVE & LOAD CONFIG (SMTP credentials)

# ============================================================

def save_config(config):

with open(CONFIG_FILE, "w") as f:

json.dump(config, f, indent=2)

print(" Configuration saved.")

def load_config():

if Path(CONFIG_FILE).exists():

with open(CONFIG_FILE, "r") as f:

return json.load(f)

return None

# ============================================================

# SAVE & LOAD SCHEDULED EMAILS

# ============================================================

def save_schedule(emails):

with open(SCHEDULE_FILE, "w") as f:

json.dump(emails, f, indent=2)

def load_schedule():

if Path(SCHEDULE_FILE).exists():

try:

with open(SCHEDULE_FILE, "r") as f:

return json.load(f)

except:

return []

# ============================================================

# SETUP SMTP CREDENTIALS

# ============================================================

def setup_credentials():

print("\n" + "="*55)

print(" SMTP CREDENTIALS SETUP")

print("="*55)

print("\n Supported providers:")

print(" 1. Gmail (smtp.gmail.com : 587)")

print(" 2. Outlook (smtp.office365.com : 587)")

print(" 3. Yahoo (smtp.mail.yahoo.com : 587)")

print(" 4. Custom SMTP")

choice = input("\n Choose provider (1-4): ").strip()

providers = {

"1": ("smtp.gmail.com", 587),

"2": ("smtp.office365.com", 587),

"3": ("smtp.mail.yahoo.com", 587),

}

if choice in providers:

smtp_host, smtp_port = providers[choice]

else:

smtp_host = input(" SMTP Host: ").strip()

smtp_port = int(input(" SMTP Port: ").strip())

email = input("\n Your email address: ").strip()

password = input(" App password (NOT your login password): ").strip()

config = {

"smtp_host": smtp_host,

"smtp_port": smtp_port,

"email": email,

"password": password

}

# Test connection

print("\n Testing connection...")

try:

server = smtplib.SMTP(smtp_host, smtp_port)

server.starttls()

server.login(email, password)

server.quit()

print(" Connection successful!")

save_config(config)

except Exception as e:

print(f" Connection failed: {e}")

print(" Tip: Use an App Password, not your account password.")

print(" Gmail: myaccount.google.com → Security → App Passwords")

return config

# ============================================================

# SEND EMAIL

# ============================================================

def send_email(config, to, subject, body, attachment_path=None, is_html=False):

try:

msg = MIMEMultipart()

msg["From"] = config["email"]

msg["To"] = to

msg["Subject"] = subject

# Body

mime_type = "html" if is_html else "plain"

msg.attach(MIMEText(body, mime_type))

# Attachment

if attachment_path and Path(attachment_path).exists():

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

part = MIMEBase("application", "octet-stream")

part.set_payload(f.read())

encoders.encode_base64(part)

part.add_header(

"Content-Disposition",

f"attachment; filename={Path(attachment_path).name}"

)

msg.attach(part)

server = smtplib.SMTP(config["smtp_host"], config["smtp_port"])

server.starttls()

server.login(config["email"], config["password"])

server.sendmail(config["email"], to, msg.as_string())

server.quit()

print(f"\n Email sent to {to} at {datetime.now().strftime('%d-%m-%Y %H:%M:%S')}")

return True

except Exception as e:

print(f"\n Failed to send email to {to}: {e}")

return False

# ============================================================

# COMPOSE EMAIL

# ============================================================

def compose_email():

print("\n" + "="*55)

print(" COMPOSE EMAIL")

print("="*55)

to = input("\n To (email address): ").strip()

subject = input(" Subject: ").strip()

print(" Body (type END on a new line to finish):")

lines = []

while True:

line = input()

if line.strip().upper() == "END":

break

lines.append(line)

body = "\n".join(lines)

attachment = input("\n Attachment path (or press Enter to skip): ").strip()

attachment = attachment if attachment and Path(attachment).exists() else None

if attachment is None and input(" Was that a path? File not found - skip attachment? (y/n): ").strip().lower() != "n":

attachment = None

return {

"to": to,

"subject": subject,

"body": body,

"attachment": attachment,

"is_html": False

}

# ============================================================

# SCHEDULE EMAIL

# ============================================================

def schedule_email(email_data):

print("\n" + "="*55)

print(" SCHEDULE EMAIL")

print("="*55)

print("\n Schedule type:")

print(" 1. One-time (specific date & time)")

print(" 2. Daily (every day at a time)")

print(" 3. Weekly (specific day each week)")

print(" 4. Send NOW")

stype = input("\n Choice (1-4): ").strip()

if stype == "1":

dt_str = input(" Send at (DD-MM-YYYY HH:MM): ").strip()

try:

send_at = datetime.strptime(dt_str, "%d-%m-%Y %H:%M")

email_data["schedule_type"] = "once"

email_data["send_at"] = send_at.strftime("%d-%m-%Y %H:%M")

email_data["sent"] = False

except ValueError:

print(" Invalid date format.")

return None

elif stype == "2":

time_str = input(" Daily at (HH:MM): ").strip()

email_data["schedule_type"] = "daily"

email_data["send_at"] = time_str

email_data["sent"] = False

elif stype == "3":

days = ["monday","tuesday","wednesday","thursday","friday","saturday","sunday"]

print(" Days:", ", ".join(d.capitalize() for d in days))

day = input(" Day: ").strip().lower()

time_str = input(" Time (HH:MM): ").strip()

if day not in days:

print(" Invalid day.")

return None

email_data["schedule_type"] = "weekly"

email_data["send_day"] = day

email_data["send_at"] = time_str

email_data["sent"] = False

elif stype == "4":

email_data["schedule_type"] = "now"

email_data["sent"] = False

else:

print(" Invalid choice.")

return None

email_data["id"] = datetime.now().strftime("%Y%m%d%H%M%S")

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

return email_data

# ============================================================

# VIEW SCHEDULED EMAILS

# ============================================================

def view_scheduled(emails):

pending = [e for e in emails if not e.get("sent")]

sent = [e for e in emails if e.get("sent")]

print("\n" + "="*55)

print(f" SCHEDULED EMAILS ({len(pending)} pending, {len(sent)} sent)")

print("="*55)

if not emails:

print("\n No emails scheduled yet.")

return

if pending:

print("\n PENDING:")

for i, e in enumerate(pending, 1):

print(f"\n [{i}] To: {e['to']}")

print(f" Subject: {e['subject']}")

stype = e.get("schedule_type", "")

if stype == "once":

print(f" Send at: {e['send_at']} (one-time)")

elif stype == "daily":

print(f" Daily at: {e['send_at']}")

elif stype == "weekly":

print(f" Weekly: {e['send_day'].capitalize()} at {e['send_at']}")

print(f" Created: {e.get('created','')}")

if sent:

print("\n SENT:")

for e in sent[-5:]: # show last 5 sent

print(f" • [{e['to']}] \"{e['subject']}\" — sent {e.get('sent_at','')}")

# ============================================================

# DELETE SCHEDULED EMAIL

# ============================================================

def delete_scheduled(emails):

pending = [e for e in emails if not e.get("sent")]

if not pending:

print("\n 📭 No pending emails to delete.")

return emails

view_scheduled(emails)

try:

idx = int(input("\n Enter number to delete: ").strip()) - 1

if 0 <= idx < len(pending):

removed = pending[idx]

emails = [e for e in emails if e["id"] != removed["id"]]

save_schedule(emails)

print(f" 🗑 Deleted email to {removed['to']}")

else:

print(" Invalid number.")

except ValueError:

print(" Invalid input.")

return emails

# ============================================================

# SCHEDULER RUNNER (Background Thread)

# ============================================================

def run_scheduler(config, emails_ref):

print(" Scheduler running in background...")

while True:

now = datetime.now()

now_time = now.strftime("%H:%M")

now_day = now.strftime("%A").lower()

for email in emails_ref:

if email.get("sent"):

continue

stype = email.get("schedule_type")

should_send = False

if stype == "now":

should_send = True

elif stype == "once":

try:

send_dt = datetime.strptime(email["send_at"], "%d-%m-%Y %H:%M")

if now >= send_dt and not email.get("sent"):

should_send = True

except:

pass

elif stype == "daily":

if now_time == email.get("send_at"):

should_send = True

elif stype == "weekly":

if now_day == email.get("send_day") and now_time == email.get("send_at"):

should_send = True

if should_send:

success = send_email(

config,

email["to"],

email["subject"],

email["body"],

email.get("attachment"),

email.get("is_html", False)

)

if success:

email["sent"] = True

email["sent_at"] = now.strftime("%d-%m-%Y %H:%M:%S")

save_schedule(emails_ref)

time.sleep(30) # Check every 30 seconds

# ============================================================

# MAIN MENU

# ============================================================

def print_menu():

print("\n" + "-"*45)

print(" AUTO EMAIL SCHEDULER")

print("-"*45)

print(" 1. Setup / Update SMTP credentials")

print(" 2. Compose & Schedule new email")

print(" 3. View scheduled emails")

print(" 4. Delete a scheduled email")

print(" 5. Start scheduler (monitor & send)")

print(" 0. Exit")

print("-"*45)

def main():

print("\n" + "="*55)

print(" AUTO EMAIL SCHEDULER")

print("="*55)

config = load_config()

emails = load_schedule()

if config:

print(f"\n Loaded credentials for: {config['email']}")

else:

print("\n ⚠ No credentials found. Please set up SMTP first (Option 1).")

scheduler_thread = None

while True:

print_menu()

choice = input(" > ").strip()

if choice == "1":

config = setup_credentials()

elif choice == "2":

if not config:

print("\n Please set up SMTP credentials first (Option 1).")

continue

email_data = compose_email()

if email_data:

scheduled = schedule_email(email_data)

if scheduled:

emails.append(scheduled)

save_schedule(emails)

print(f"\n Email scheduled successfully! (ID: {scheduled['id']})")

elif choice == "3":

view_scheduled(emails)

elif choice == "4":

emails = delete_scheduled(emails)

elif choice == "5":

if not config:

print("\n Please set up SMTP credentials first.")

continue

if scheduler_thread and scheduler_thread.is_alive():

print("\n Scheduler is already running.")

else:

scheduler_thread = threading.Thread(

target=run_scheduler,

args=(config, emails),

daemon=True

)

scheduler_thread.start()

print("\n Scheduler started! It checks every 30 seconds.")

print(" Keep this window open. Press 0 to exit.\n")

elif choice == "0":

print("\n Goodbye! Scheduled emails will not send after exit.\n")

break

else:

print(" Invalid choice.")

# ============================================================

# RUN

# ============================================================

if __name__ == "__main__":

main()

Clipboard History Manager

import pyperclip

import keyboard

import json

import os

import time

import threading

from datetime import datetime

from pathlib import Path

# ============================================================

# CONFIGURATION

# ============================================================

HISTORY_FILE = "clipboard_history.json"

MAX_ENTRIES = 50 # Maximum clipboard entries to store

POLL_INTERVAL = 1.0 # Seconds between clipboard checks

PREVIEW_LEN = 60 # Characters to show in preview

# ============================================================

# LOAD & SAVE HISTORY

# ============================================================

def load_history():

if Path(HISTORY_FILE).exists():

try:

with open(HISTORY_FILE, "r", encoding="utf-8") as f:

return json.load(f)

except:

return []

def save_history(history):

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

json.dump(history, f, indent=2, ensure_ascii=False)

# ============================================================

# ADD ENTRY

# ============================================================

def add_entry(history, text):

# Avoid duplicate consecutive entries

if history and history[-1]["text"] == text:

return history

# Avoid duplicates anywhere in history — move to top instead

history = [h for h in history if h["text"] != text]

entry = {

"text": text,

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

"length": len(text)

}

history.append(entry)

# Keep only last MAX_ENTRIES

if len(history) > MAX_ENTRIES:

history = history[-MAX_ENTRIES:]

save_history(history)

return history

# ============================================================

# MONITOR CLIPBOARD (Background Thread)

# ============================================================

class ClipboardMonitor(threading.Thread):

def __init__(self):

super().__init__(daemon=True)

self.history = load_history()

self.last_text = ""

self.running = True

self.entry_count = len(self.history)

def run(self):

print(" Clipboard monitor started (background)...")

while self.running:

try:

current = pyperclip.paste()

if current and current != self.last_text:

self.history = add_entry(self.history, current)

self.last_text = current

new_count = len(self.history)

if new_count != self.entry_count:

preview = current[:PREVIEW_LEN].replace("\n", " ")

print(f"\n Captured: \"{preview}{'...' if len(current) > PREVIEW_LEN else ''}\"")

print(" > ", end="", flush=True)

self.entry_count = new_count

except:

pass

time.sleep(POLL_INTERVAL)

def stop(self):

self.running = False

# ============================================================

# DISPLAY HISTORY

# ============================================================

def display_history(history):

if not history:

print("\n No clipboard history yet.")

return

print("\n" + "="*60)

print(f" CLIPBOARD HISTORY ({len(history)} entries)")

print("="*60)

for i, entry in enumerate(reversed(history), 1):

preview = entry["text"][:PREVIEW_LEN].replace("\n", " ")

dots = "..." if len(entry["text"]) > PREVIEW_LEN else ""

print(f"\n [{i:02d}] {entry['timestamp']} | {entry['length']} chars")

print(f" \"{preview}{dots}\"")

print("\n" + "="*60)

# ============================================================

# SEARCH HISTORY

# ============================================================

def search_history(history, keyword):

keyword_lower = keyword.lower()

results = [

(i, h) for i, h in enumerate(history)

if keyword_lower in h["text"].lower()

]

if not results:

print(f"\n No results found for: \"{keyword}\"")

return

print(f"\n Found {len(results)} result(s) for \"{keyword}\":\n")

print("-"*60)

for rank, (idx, entry) in enumerate(results, 1):

preview = entry["text"][:PREVIEW_LEN].replace("\n", " ")

dots = "..." if len(entry["text"]) > PREVIEW_LEN else ""

print(f" [{rank}] 🕒 {entry['timestamp']} (index {idx+1})")

print(f" \"{preview}{dots}\"")

print()

# ============================================================

# RESTORE TO CLIPBOARD

# ============================================================

def restore_entry(history, index):

"""Copy a history entry back to clipboard by display index (1-based, newest first)."""

if index < 1 or index > len(history):

print(" Invalid index.")

return

# Display is reversed so index 1 = last item

real_index = len(history) - index

entry = history[real_index]

pyperclip.copy(entry["text"])

preview = entry["text"][:PREVIEW_LEN].replace("\n", " ")

print(f"\n Restored to clipboard: \"{preview}{'...' if len(entry['text']) > PREVIEW_LEN else ''}\"")

# ============================================================

# DELETE ENTRY

# ============================================================

def delete_entry(history, index):

if index < 1 or index > len(history):

print(" Invalid index.")

return history

real_index = len(history) - index

removed = history.pop(real_index)

save_history(history)

preview = removed["text"][:PREVIEW_LEN].replace("\n", " ")

print(f"\n Deleted: \"{preview}{'...' if len(removed['text']) > PREVIEW_LEN else ''}\"")

return history

# ============================================================

# CLEAR ALL HISTORY

# ============================================================

def clear_history():

confirm = input("\n ⚠ Clear ALL clipboard history? (yes/no): ").strip().lower()

if confirm == "yes":

save_history([])

print(" Clipboard history cleared.")

return []

print(" Cancelled.")

return load_history()

# ============================================================

# EXPORT HISTORY TO TXT

# ============================================================

def export_history(history):

if not history:

print(" Nothing to export.")

return

filename = f"clipboard_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"

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

f.write("CLIPBOARD HISTORY EXPORT\n")

f.write(f"Exported: {datetime.now().strftime('%d-%m-%Y %H:%M:%S')}\n")

f.write(f"Total entries: {len(history)}\n")

f.write("="*60 + "\n\n")

for i, entry in enumerate(reversed(history), 1):

f.write(f"[{i:02d}] {entry['timestamp']} ({entry['length']} chars)\n")

f.write(entry["text"] + "\n")

f.write("-"*60 + "\n\n")

print(f"\n Exported to: {filename}")

# ============================================================

# MAIN MENU

# ============================================================

def print_menu():

print("\n" + "-"*40)

print(" CLIPBOARD HISTORY MANAGER")

print("-"*40)

print(" 1. View history")

print(" 2. Search history")

print(" 3. Restore entry to clipboard")

print(" 4. Delete an entry")

print(" 5. Export history to .txt")

print(" 6. Clear all history")

print(" 0. Exit")

print("-"*40)

def main():

print("\n" + "="*55)

print(" CLIPBOARD HISTORY MANAGER")

print("="*55)

print(f"\n Max entries : {MAX_ENTRIES}")

print(f" History file: {HISTORY_FILE}")

print(f" Poll interval: every {POLL_INTERVAL}s")

# Start background monitor

monitor = ClipboardMonitor()

monitor.start()

time.sleep(0.5)

while True:

print_menu()

choice = input(" > ").strip()

if choice == "1":

display_history(monitor.history)

elif choice == "2":

keyword = input("\n Search keyword: ").strip()

if keyword:

search_history(monitor.history, keyword)

elif choice == "3":

display_history(monitor.history)

try:

idx = int(input("\n Enter entry number to restore: ").strip())

restore_entry(monitor.history, idx)

except ValueError:

print(" Invalid number.")

elif choice == "4":

display_history(monitor.history)

try:

idx = int(input("\n Enter entry number to delete: ").strip())

monitor.history = delete_entry(monitor.history, idx)

except ValueError:

print(" Invalid number.")

elif choice == "5":

export_history(monitor.history)

elif choice == "6":

monitor.history = clear_history()

elif choice == "0":

monitor.stop()

print("\n Clipboard History Manager closed. Goodbye!\n")

break

else:

print(" Invalid choice. Try again.")

# ============================================================

# RUN

# ============================================================

if __name__ == "__main__":

main()

Blog Pages

Simple Chatbot with Pattern Matching

Website Uptime Monitor

Screen Time Tracker

Auto Email Scheduler

Clipboard History Manager