Python Automation Scripts 2026 — Automate Everything With Python

import os
import shutil
from pathlib import Path

def organize_downloads(downloads_path: str) -> dict:
    """Sort files in downloads folder into subfolders by type."""
    
    CATEGORIES = {
        "Images": [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".bmp"],
        "Videos": [".mp4", ".mkv", ".avi", ".mov", ".wmv"],
        "Documents": [".pdf", ".doc", ".docx", ".txt", ".odt"],
        "Spreadsheets": [".xls", ".xlsx", ".csv"],
        "Code": [".py", ".js", ".ts", ".html", ".css", ".json"],
        "Archives": [".zip", ".rar", ".7z", ".tar", ".gz"],
        "Audio": [".mp3", ".wav", ".flac", ".aac"],
    }
    
    downloads = Path(downloads_path)
    moved = {}
    
    for file in downloads.iterdir():
        if not file.is_file():
            continue
        
        suffix = file.suffix.lower()
        destination_folder = None
        
        for category, extensions in CATEGORIES.items():
            if suffix in extensions:
                destination_folder = category
                break
        
        if destination_folder is None:
            destination_folder = "Other"
        
        dest_dir = downloads / destination_folder
        dest_dir.mkdir(exist_ok=True)
        
        dest_path = dest_dir / file.name
        if not dest_path.exists():
            shutil.move(str(file), str(dest_path))
            moved[category] = moved.get(category, 0) + 1
    
    return moved

result = organize_downloads(r"C:\Users\User\Downloads")
for category, count in result.items():
    print(f"Moved {count} files to {category}/")

from pathlib import Path
import re

def batch_rename(folder: str, pattern: str, replacement: str) -> int:
    """Rename files matching a pattern in a folder."""
    path = Path(folder)
    count = 0
    
    for file in path.iterdir():
        if file.is_file():
            new_name = re.sub(pattern, replacement, file.name)
            if new_name != file.name:
                file.rename(file.parent / new_name)
                print(f"  {file.name} → {new_name}")
                count += 1
    
    return count

# Example: rename "IMG_20260501_143022.jpg" → "2026-05-01_photo.jpg"
count = batch_rename(
    r"C:\Users\User\Photos",
    r"IMG_(\d{4})(\d{2})(\d{2})_\d+",
    r"\1-\2-\3_photo"
)
print(f"Renamed {count} files")

import shutil
import os
from datetime import datetime
from pathlib import Path

def backup_folder(source: str, backup_root: str, keep_last: int = 7) -> str:
    """Create a timestamped backup of a folder, keeping only the last N."""
    source_path = Path(source)
    backup_dir = Path(backup_root)
    backup_dir.mkdir(parents=True, exist_ok=True)
    
    timestamp = datetime.now().strftime("%Y-%m-%d_%H%M%S")
    folder_name = source_path.name
    backup_path = backup_dir / f"{folder_name}_{timestamp}"
    
    shutil.copytree(source, backup_path)
    print(f"Backup created: {backup_path}")
    
    # Remove old backups
    backups = sorted(backup_dir.glob(f"{folder_name}_*"), reverse=True)
    for old_backup in backups[keep_last:]:
        shutil.rmtree(old_backup)
        print(f"Removed old backup: {old_backup.name}")
    
    return str(backup_path)

backup_folder(
    r"C:\Users\User\Documents\Projects",
    r"D:\Backups",
    keep_last=7
)

import pandas as pd
from pathlib import Path

def merge_monthly_reports(reports_folder: str, output_file: str) -> int:
    """Merge all CSV reports in a folder into one master file."""
    folder = Path(reports_folder)
    all_dfs = []
    
    for csv_file in sorted(folder.glob("*.csv")):
        df = pd.read_csv(csv_file)
        df["source_file"] = csv_file.name  # Track which file each row came from
        all_dfs.append(df)
        print(f"Loaded: {csv_file.name} ({len(df)} rows)")
    
    if not all_dfs:
        print("No CSV files found")
        return 0
    
    merged = pd.concat(all_dfs, ignore_index=True)
    merged.to_csv(output_file, index=False)
    print(f"\nMerged {len(all_dfs)} files → {len(merged)} total rows → {output_file}")
    return len(merged)

merge_monthly_reports("monthly_reports/", "full_year_report.csv")

import pandas as pd
from openpyxl.styles import PatternFill, Font, Alignment
from openpyxl.utils import get_column_letter

def create_sales_report(data: pd.DataFrame, output_file: str) -> None:
    """Create a formatted Excel report from a DataFrame."""
    with pd.ExcelWriter(output_file, engine="openpyxl") as writer:
        data.to_excel(writer, index=False, sheet_name="Sales Data")
        
        workbook = writer.book
        worksheet = writer.sheets["Sales Data"]
        
        # Style header row
        header_fill = PatternFill("solid", fgColor="4F46E5")
        header_font = Font(color="FFFFFF", bold=True)
        
        for cell in worksheet[1]:
            cell.fill = header_fill
            cell.font = header_font
            cell.alignment = Alignment(horizontal="center")
        
        # Auto-fit column widths
        for i, column in enumerate(data.columns, 1):
            max_length = max(len(str(column)), data[column].astype(str).str.len().max())
            worksheet.column_dimensions[get_column_letter(i)].width = min(max_length + 4, 40)
    
    print(f"Report saved: {output_file}")

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders
from pathlib import Path
import os

def send_email(
    to: str | list[str],
    subject: str,
    body_html: str,
    attachments: list[str] | None = None,
    smtp_server: str = "smtp.gmail.com",
    smtp_port: int = 587,
) -> bool:
    """Send an email with optional attachments."""
    
    sender = os.environ["EMAIL_ADDRESS"]
    password = os.environ["EMAIL_APP_PASSWORD"]  # Use App Password, not real password
    
    msg = MIMEMultipart("alternative")
    msg["From"] = sender
    msg["To"] = ", ".join(to) if isinstance(to, list) else to
    msg["Subject"] = subject
    msg.attach(MIMEText(body_html, "html"))
    
    # Attach files
    for filepath in (attachments or []):
        path = Path(filepath)
        with open(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.name}")
        msg.attach(part)
    
    try:
        with smtplib.SMTP(smtp_server, smtp_port) as server:
            server.starttls()
            server.login(sender, password)
            server.send_message(msg)
        print(f"Email sent to {msg['To']}")
        return True
    except Exception as e:
        print(f"Failed to send email: {e}")
        return False

# Send weekly report
send_email(
    to="team@company.com",
    subject="Weekly Sales Report — May 2026",
    body_html="<h2>Weekly Report</h2><p>See attached for this week's sales data.</p>",
    attachments=["weekly_report.xlsx"]
)

import schedule
import time
import logging
from datetime import datetime

logging.basicConfig(level=logging.INFO, format="%(asctime)s — %(message)s")
logger = logging.getLogger(__name__)

def morning_report():
    logger.info("Generating morning report...")
    # Your report generation code here
    logger.info("Morning report sent!")

def backup_job():
    logger.info("Running daily backup...")
    # Your backup code here
    logger.info("Backup complete!")

def weekly_cleanup():
    logger.info("Running weekly cleanup...")
    # Your cleanup code here

# Schedule jobs
schedule.every().day.at("08:00").do(morning_report)
schedule.every().day.at("23:00").do(backup_job)
schedule.every().monday.at("09:00").do(weekly_cleanup)
schedule.every(30).minutes.do(lambda: logger.info("Heartbeat OK"))

logger.info("Scheduler started. Press Ctrl+C to stop.")
while True:
    schedule.run_pending()
    time.sleep(60)

:: Create a .bat file: run_script.bat
@echo off
cd /d "C:\path\to\your\script"
"C:\path\to\python.exe" your_script.py >> logs\output.log 2>&1

from playwright.sync_api import sync_playwright

def automate_login_and_download(url: str, username: str, password: str) -> None:
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        
        page.goto(url)
        
        # Fill login form
        page.fill("#username", username)
        page.fill("#password", password)
        page.click("button[type='submit']")
        
        # Wait for redirect after login
        page.wait_for_url("**/dashboard**")
        print("Logged in successfully")
        
        # Navigate to reports
        page.click("text=Reports")
        page.wait_for_selector(".report-table")
        
        # Trigger download
        with page.expect_download() as download_info:
            page.click("button.download-csv")
        download = download_info.value
        download.save_as("report_downloaded.csv")
        print(f"Downloaded: report_downloaded.csv")
        
        browser.close()

import psutil
import smtplib
import time

def monitor_system(
    cpu_threshold: float = 90.0,
    memory_threshold: float = 85.0,
    disk_threshold: float = 90.0,
    check_interval: int = 60
) -> None:
    """Monitor system resources and alert when thresholds are exceeded."""
    
    print(f"Monitoring system... Checking every {check_interval}s")
    
    while True:
        cpu = psutil.cpu_percent(interval=1)
        memory = psutil.virtual_memory().percent
        disk = psutil.disk_usage("/").percent
        
        alerts = []
        if cpu > cpu_threshold:
            alerts.append(f"CPU: {cpu:.1f}% (threshold: {cpu_threshold}%)")
        if memory > memory_threshold:
            alerts.append(f"Memory: {memory:.1f}% (threshold: {memory_threshold}%)")
        if disk > disk_threshold:
            alerts.append(f"Disk: {disk:.1f}% (threshold: {disk_threshold}%)")
        
        if alerts:
            message = "ALERT: System thresholds exceeded\n" + "\n".join(alerts)
            print(f"\n{message}")
            # send_email(to="admin@company.com", subject="System Alert", body_html=message)
        else:
            print(f"\rCPU: {cpu:.1f}% | RAM: {memory:.1f}% | Disk: {disk:.1f}%", end="")
        
        time.sleep(check_interval)