import pyperclip
import re
import time

RULES = [
    # 1. Clean Google/Affiliate Tracking URLs
    (re.compile(r'(\?|&)(utm_.*?|aff_.*?|ref=.*?)=[^&]*'), ''),
    
    # 2. Convert PascalCase to snake_case
    (re.compile(r'(.)([A-Z][a-z]+)'), r'\1_\2'),
    (re.compile(r'([a-z0-9])([A-Z])'), r'\1_\2')
]

def apply_rules(text):
    for pattern, replacement in RULES:
        text = pattern.sub(replacement, text).lower()
    return text

if __name__ == "__main__":
    recent_value = pyperclip.paste()
    print("Clipboard Engine running... Press Ctrl+C to stop.")
    
    while True:
        try:
            current_value = pyperclip.paste()
            if current_value != recent_value:
                transformed_value = apply_rules(current_value)
                
                if transformed_value != current_value:
                    print(f"Clipboard updated. Original: '{current_value[:30]}...' -> New: '{transformed_value[:30]}...'")
                    pyperclip.copy(transformed_value)
                
                recent_value = pyperclip.paste() # Update with the potentially new value
            time.sleep(0.5)
        except KeyboardInterrupt:
            break

import mmap
import os
import shutil

def zero_copy_transfer(source_path, dest_path):
    """Copies a file using memory mapping for speed."""
    if not os.path.exists(source_path):
        print(f"Error: Source file not found at {source_path}")
        return

    # Use shutil.copyfile if the file is small (mmap overhead isn't worth it)
    file_size = os.path.getsize(source_path)
    if file_size < 1024 * 1024 * 5:  # 5 MB threshold
        shutil.copyfile(source_path, dest_path)
        print(f"Standard copy used for small file: {source_path}")
        return

    try:
        with open(source_path, 'rb') as f_in, open(dest_path, 'wb') as f_out:
            # Resize the output file to the same size as the input file
            f_out.truncate(file_size) 
            
            # Map the file into memory
            with mmap.mmap(f_out.fileno(), file_size, access=mmap.ACCESS_WRITE) as m:
                # Read the source data directly into the memory-mapped object
                data = f_in.read()
                m.write(data)
                m.flush()
        
        print(f"Zero-copy transfer complete: {source_path} -> {dest_path}")
        
    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    # Replace these paths with your large file test
    SOURCE = 'large_log_file.txt'  
    DEST = 'large_log_file_copy.txt' 
    
    # NOTE: You need a large file at SOURCE path to test this effectively
    # You might want to create a dummy 100MB file first!
    
    # zero_copy_transfer(SOURCE, DEST)
    print("Script ready. Replace file names and uncomment 'zero_copy_transfer' to run.")

import os
import time
import datetime
import shutil

SOURCE_DIR = '/path/to/your/important/data'  # <-- CHANGE THIS
BACKUP_ROOT = '/path/to/your/backup/drive'    # <-- CHANGE THIS

def get_last_snapshot(root_dir):
    """Finds the path to the most recent daily snapshot."""
    snapshots = [d for d in os.listdir(root_dir) if os.path.isdir(os.path.join(root_dir, d))]
    if not snapshots:
        return None
    snapshots.sort(reverse=True)
    return os.path.join(root_dir, snapshots[0])

def run_hardlink_backup():
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S")
    new_snapshot_dir = os.path.join(BACKUP_ROOT, timestamp)
    
    last_snapshot_dir = get_last_snapshot(BACKUP_ROOT)
    
    print(f"Creating new snapshot: {new_snapshot_dir}")
    os.makedirs(new_snapshot_dir, exist_ok=True)
    
    # 1. Hardlink all unchanged files from the last snapshot
    if last_snapshot_dir:
        for root, _, files in os.walk(last_snapshot_dir):
            relative_path = os.path.relpath(root, last_snapshot_dir)
            target_root = os.path.join(new_snapshot_dir, relative_path)
            os.makedirs(target_root, exist_ok=True)
            
            for file in files:
                src_file = os.path.join(root, file)
                dest_file = os.path.join(target_root, file)
                try:
                    # Skip if the source file doesn't exist anymore
                    if os.path.exists(os.path.join(SOURCE_DIR, relative_path, file)):
                        os.link(src_file, dest_file)
                except Exception:
                    pass # Ignore errors for now

    # 2. Copy/Overwrite changed files from the SOURCE_DIR
    for root, dirs, files in os.walk(SOURCE_DIR):
        relative_path = os.path.relpath(root, SOURCE_DIR)
        target_root = os.path.join(new_snapshot_dir, relative_path)
        os.makedirs(target_root, exist_ok=True)
        
        for file in files:
            src_file = os.path.join(root, file)
            dest_file = os.path.join(target_root, file)
            
            # Check if file has changed (simple check: size/mod time comparison)
            if not last_snapshot_dir or \
               not os.path.exists(os.path.join(last_snapshot_dir, relative_path, file)) or \
               os.path.getmtime(src_file) > os.path.getmtime(os.path.join(last_snapshot_dir, relative_path, file)):
                
                print(f"Copying (changed/new): {file}")
                shutil.copy2(src_file, dest_file) # copy2 preserves metadata
            # Else: File already hardlinked from step 1

    print("Backup finished.")

if __name__ == "__main__":
    # IMPORTANT: Update SOURCE_DIR and BACKUP_ROOT paths
    # run_hardlink_backup()
    print("Script ready. Please update paths and uncomment 'run_hardlink_backup' to run.")

import os
import re
import requests

DOCS_DIR = './docs' # <-- CHANGE THIS to your docs folder

def check_link(link, base_path):
    """Checks if a link is valid (local file or external URL)."""
    if link.startswith('http'):
        # External link check
        try:
            response = requests.head(link, timeout=5, allow_redirects=True)
            if response.status_code >= 400:
                return f"External link broken: Status {response.status_code}"
            return "OK"
        except requests.RequestException as e:
            return f"External link failed: {e.__class__.__name__}"
    elif link.startswith('#'):
        # Anchor links are tricky to validate robustly, skipping for simplicity
        return "Anchor (SKIPPED)" 
    else:
        # Local file check
        full_path = os.path.join(os.path.dirname(base_path), link)
        if not os.path.exists(full_path):
            # Check if it's an absolute path from DOCS_DIR root
            if not os.path.exists(os.path.join(DOCS_DIR, link)):
                 return f"Local file missing: {full_path}"
            
        return "OK"

def find_and_check_links():
    # RegEx to find Markdown links: [text](link)
    LINK_REGEX = re.compile(r'\[.*?\]\((.*?)\)') 
    
    print(f"Scanning for links in {DOCS_DIR}...")
    broken_links = 0

    for root, _, files in os.walk(DOCS_DIR):
        for file_name in files:
            if file_name.endswith('.md'):
                file_path = os.path.join(root, file_name)
                with open(file_path, 'r', encoding='utf-8') as f:
                    content = f.read()
                    
                    for match in LINK_REGEX.finditer(content):
                        link = match.group(1).split()[0] # Take link, ignore optional title
                        result = check_link(link, file_path)
                        
                        if result != "OK" and "SKIPPED" not in result:
                            broken_links += 1
                            print(f"[🚨 BROKEN] File: {file_path}, Link: {link}, Reason: {result}")

    if broken_links == 0:
        print("\n✅ All links seem fine!")
    else:
        print(f"\n❌ Found {broken_links} broken links.")

if __name__ == "__main__":
    # You need the 'requests' library: pip install requests
    # find_and_check_links()
    print("Script ready. Update DOCS_DIR and uncomment 'find_and_check_links' to run.")

import imaplib
import time
import re

# --- CONFIGURATION ---
IMAP_SERVER = 'imap.gmail.com'
EMAIL_ADDRESS = 'your_email@gmail.com' # <-- CHANGE THIS
PASSWORD = 'your_app_password'         # <-- CHANGE THIS (Use App Password for Gmail)
MONITOR_FOLDER = 'INBOX'
URGENT_REGEX = re.compile(r'(failed|alert|critical|deploy|error)', re.IGNORECASE)
# ---------------------

def imap_idle_triage():
    try:
        # Connect and Login
        mail = imaplib.IMAP4_SSL(IMAP_SERVER)
        mail.login(EMAIL_ADDRESS, PASSWORD)
        mail.select(MONITOR_FOLDER)
        print(f"Logged in and monitoring {MONITOR_FOLDER} using IDLE...")

        while True:
            # Send IDLE command
            mail.send(b'A001 IDLE\r\n')
            
            # Wait for the server to send a response (new data or timeout)
            response = mail.readline()
            
            # If the server responds with an update (like EXISTS or RECENT)
            if b'OK' not in response:
                print("\nNew mail activity detected!")
                mail.send(b'DONE\r\n') # Stop IDLE command
                mail.readline()      # Consume server response
                
                # Check for new, urgent emails
                status, messages = mail.search(None, 'UNSEEN')
                
                if status == 'OK':
                    for msg_id in messages[0].split():
                        # Fetch the Envelope/Subject only
                        status, data = mail.fetch(msg_id, '(ENVELOPE)')
                        
                        if status == 'OK':
                            envelope_data = data[0][1].decode('utf-8')
                            # Simple extraction of the subject line from the envelope data (complex regex needed for full robust extraction)
                            subject_match = re.search(r'"([^"]*)"', envelope_data) 
                            subject = subject_match.group(1) if subject_match else "[Subject Not Found]"

                            if URGENT_REGEX.search(subject):
                                print(f"🚨 URGENT EMAIL: {subject}")
                                # Add code here to trigger a system notification or a text message
                            else:
                                print(f"New email: {subject}")
                                
                    mail.select(MONITOR_FOLDER) # Reselect the folder
            
            time.sleep(1) # Small pause before next IDLE check/loop

    except Exception as e:
        print(f"IMAP IDLE error: {e}")
    finally:
        try:
            mail.logout()
        except:
            pass

if __name__ == "__main__":
    # IMPORTANT: Update configurations and use an App Password for secure login
    # imap_idle_triage()
    print("Script ready. Update config and uncomment 'imap_idle_triage' to run.")

import os
import sqlite3
from PIL import Image
import pytesseract # pip install pytesseract, and install Tesseract-OCR engine separately!

SCREENSHOTS_DIR = './screenshots' # <-- CHANGE THIS
DB_PATH = 'ocr_index.db'
IMAGE_EXTENSIONS = ('.png', '.jpg', '.jpeg')

def create_db(conn):
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS ocr_data (
            filepath TEXT PRIMARY KEY,
            ocr_text TEXT,
            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
        )
    """)
    conn.commit()

def process_screenshots():
    conn = sqlite3.connect(DB_PATH)
    create_db(conn)
    cursor = conn.cursor()

    for root, _, files in os.walk(SCREENSHOTS_DIR):
        for file_name in files:
            if file_name.lower().endswith(IMAGE_EXTENSIONS):
                file_path = os.path.join(root, file_name)
                
                # Check if already indexed
                cursor.execute("SELECT filepath FROM ocr_data WHERE filepath = ?", (file_path,))
                if cursor.fetchone():
                    continue

                try:
                    # OCR process
                    text = pytesseract.image_to_string(Image.open(file_path))
                    
                    # Store data
                    cursor.execute("INSERT INTO ocr_data (filepath, ocr_text) VALUES (?, ?)", 
                                   (file_path, text))
                    conn.commit()
                    print(f"Indexed: {file_name}")
                except Exception as e:
                    print(f"Could not process {file_name}: {e}")

    conn.close()

def search_screenshots(query):
    conn = sqlite3.connect(DB_PATH)
    cursor = conn.cursor()
    
    # Use LIKE for simple full-text search
    cursor.execute("SELECT filepath, ocr_text FROM ocr_data WHERE ocr_text LIKE ?", (f'%{query}%',))
    results = cursor.fetchall()
    conn.close()
    
    if results:
        print(f"\n--- Found {len(results)} matches for '{query}' ---")
        for filepath, text in results:
            print(f"Match in: {filepath}")
            # print(f"Snippet: {text[:200]}...") # Optional: print snippet
    else:
        print(f"\nNo matches found for '{query}'.")

if __name__ == "__main__":
    # You need pytesseract and the Tesseract engine installed
    # process_screenshots()
    # search_screenshots("your search term here")
    print("Script ready. Install pytesseract/Tesseract, update config, then run process/search functions.")

import ast
import sys
from collections import defaultdict

def analyze_python_file(filepath):
    """Analyzes a Python file to track imported modules and their usage."""
    with open(filepath, 'r') as f:
        tree = ast.parse(f.read())

    imported_names = {} # {alias: module_name or name}
    used_names = set()

    # 1. Collect all imported names
    for node in ast.walk(tree):
        if isinstance(node, ast.Import):
            for alias in node.names:
                imported_names[alias.asname or alias.name] = alias.name
        elif isinstance(node, ast.ImportFrom):
            if node.module:
                for alias in node.names:
                    imported_names[alias.asname or alias.name] = f"{node.module}.{alias.name}"
            
    # 2. Find all names used in the code
    for node in ast.walk(tree):
        if isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Load, ast.Store, ast.Del)):
            used_names.add(node.id)

    # 3. Compare and Report
    unused_imports = {}
    for alias, module_name in imported_names.items():
        # Check if the alias (or the name itself) was ever used
        if alias not in used_names:
            unused_imports[alias] = module_name
            
    print(f"--- Unused Imports in {filepath} ---")
    if unused_imports:
        for alias, module_name in unused_imports.items():
            print(f"Potential unused import: {module_name} (as {alias})")
    else:
        print("✅ Clean: No immediately obvious unused imports found.")
        
    return unused_imports

if __name__ == "__main__":
    # Example usage: Pass a Python file path
    # If you run this script on itself, it will find its own unused imports (if any)
    if len(sys.argv) < 2:
        print(f"Usage: python {sys.argv[0]} ")
    else:
        filepath = sys.argv[1]
        # analyze_python_file(filepath)
        print("Script ready. Pass a Python file path as an argument and uncomment 'analyze_python_file' to run.")

import subprocess
import datetime
from collections import defaultdict

def create_commit_heatmap(repo_path='.'):
    """Generates a text-based heatmap of commit times."""
    
    # Run git log and format the output as raw timestamps
    try:
        command = [
            'git', 'log', '--all', 
            '--pretty=format:%at' # %at is author timestamp (seconds since epoch)
        ]
        result = subprocess.run(
            command, 
            cwd=repo_path, 
            capture_output=True, 
            text=True, 
            check=True
        )
        timestamps = result.stdout.strip().split('\n')
    except subprocess.CalledProcessError as e:
        print(f"Error running git: {e.stderr.strip()}")
        return
    except FileNotFoundError:
        print("Error: Git executable not found.")
        return

    # Initialize heatmap: [Day of Week][Hour of Day]
    heatmap = defaultdict(lambda: defaultdict(int))
    
    for ts in timestamps:
        try:
            timestamp = int(ts)
            dt_object = datetime.datetime.fromtimestamp(timestamp)
            day_of_week = dt_object.weekday() # Monday is 0, Sunday is 6
            hour_of_day = dt_object.hour
            heatmap[day_of_week][hour_of_day] += 1
        except ValueError:
            continue

    # Visualization
    DAYS = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
    HOURS = [f"{h:02d}" for h in range(24)]
    
    print("\n--- Git Commit Activity Heatmap (Commits Per Hour/Day) ---")
    print("       " + " ".join(HOURS))
    print("     " + "-" * (3 * 24))
    
    for d_index, day in enumerate(DAYS):
        row = f"{day} | "
        for h_index in range(24):
            count = heatmap[d_index][h_index]
            # Use simple characters for visualization
            if count == 0:
                char = ' .' 
            elif count < 5:
                char = ' ░'
            elif count < 15:
                char = ' ▒'
            else:
                char = ' ▓'
            row += char
        print(row)

if __name__ == "__main__":
    # create_commit_heatmap('.') # Runs on the current directory if it's a Git repo
    print("Script ready. Uncomment 'create_commit_heatmap' in a Git repository to run.")

import os
from gensim.summarization import summarize # pip install gensim
from collections import deque

LOG_DIR = './daily_logs' # <-- CHANGE THIS
SUMMARY_LENGTH = 0.3 # 30% of original text length

def summarize_logs():
    all_text = []
    
    # Load all text files in the log directory
    for root, _, files in os.walk(LOG_DIR):
        for file_name in files:
            if file_name.endswith(('.txt', '.log')):
                file_path = os.path.join(root, file_name)
                try:
                    with open(file_path, 'r', encoding='utf-8') as f:
                        all_text.append(f.read())
                except Exception:
                    continue
    
    # Combine text for holistic summarization
    combined_text = "\n\n".join(all_text)
    
    if not combined_text.strip():
        print("No content found in logs to summarize.")
        return

    try:
        # Use TextRank algorithm for summarization
        summary = summarize(combined_text, ratio=SUMMARY_LENGTH) 
        
        print("\n--- Daily Log Summary ---")
        print(summary)
        print("-" * 30)
        
        # Optional: Save the summary
        with open('daily_summary.txt', 'w', encoding='utf-8') as f:
            f.write(summary)
        print("Summary saved to daily_summary.txt")

    except Exception as e:
        print(f"Summarization failed (check gensim/TextRank requirements): {e}")

if __name__ == "__main__":
    # You need the 'gensim' library: pip install gensim
    # summarize_logs()
    print("Script ready. Install gensim, update LOG_DIR, and uncomment 'summarize_logs' to run.")

from PyPDF2 import PdfReader, PdfWriter # pip install PyPDF2
import os

def pdf_split(input_path, output_dir, page_ranges):
    """Splits a PDF based on a dictionary of {title: [start_page, end_page]}."""
    reader = PdfReader(input_path)
    os.makedirs(output_dir, exist_ok=True)

    for title, (start, end) in page_ranges.items():
        writer = PdfWriter()
        # Pages are 0-indexed, so we use start-1 to end
        for page_num in range(start - 1, end): 
            writer.add_page(reader.pages[page_num])

        output_path = os.path.join(output_dir, f"{title}.pdf")
        with open(output_path, "wb") as output_file:
            writer.write(output_file)
        print(f"Created: {output_path}")

def pdf_merge(file_list, output_path):
    """Merges a list of PDFs and adds bookmarks for indexing."""
    merger = PdfWriter()

    for path in file_list:
        title = os.path.basename(path).replace(".pdf", "")
        # Get the page number where this file starts
        page_start = len(merger.pages) 
        merger.append(path)
        # Add a bookmark pointing to the start of the merged file
        merger.add_outline_item(title, page_start) 

    with open(output_path, "wb") as output_file:
        merger.write(output_file)
    print(f"Merged and indexed PDF created: {output_path}")

if __name__ == "__main__":
    # You need PyPDF2: pip install PyPDF2
    
    # --- SPLIT EXAMPLE ---
    # INPUT_PDF = 'large_manual.pdf' # <-- CHANGE THIS
    # RANGES = {
    #     "Chapter 1 - Intro": [1, 10], 
    #     "Chapter 2 - Setup": [11, 25]
    # }
    # pdf_split(INPUT_PDF, './split_output', RANGES)
    
    # --- MERGE EXAMPLE ---
    # MERGE_LIST = ['./report_a.pdf', './report_b.pdf', './report_c.pdf'] # <-- CHANGE THIS
    # pdf_merge(MERGE_LIST, 'final_combined_report.pdf')
    print("Script ready. Install PyPDF2, update file paths, and uncomment the desired function to run.")

import psutil # pip install psutil
import time
import os
import sys

def clear_screen():
    """Clears the terminal screen."""
    os.system('cls' if os.name == 'nt' else 'clear')

def get_sys_metrics():
    """Fetches core system metrics using psutil."""
    cpu_percent = psutil.cpu_percent(interval=None) # Non-blocking call
    mem_info = psutil.virtual_memory()
    disk_usage = psutil.disk_usage('/') # Use '/' for Linux/macOS, or 'C:' for Windows
    net_io = psutil.net_io_counters()

    return {
        'CPU': f"{cpu_percent:0.1f}%",
        'Memory': f"{mem_info.percent:0.1f}% ({mem_info.used / (1024**3):.2f} GB used)",
        'Disk': f"{disk_usage.percent}% ({disk_usage.free / (1024**3):.2f} GB free)",
        'Net_Sent': f"{net_io.bytes_sent / (1024**2):.2f} MB",
        'Net_Recv': f"{net_io.bytes_recv / (1024**2):.2f} MB",
    }

def run_dashboard(interval=1.0):
    clear_screen()
    print("System Resource Dashboard (Press Ctrl+C to stop)")
    print("-" * 40)
    
    # Get initial metrics to calculate CPU usage over an interval
    psutil.cpu_percent(interval=None) 

    try:
        while True:
            metrics = get_sys_metrics()
            
            # Print the dashboard
            sys.stdout.write('\033[F') # Move cursor up (only works in some terminals)
            sys.stdout.write('\033[K') # Clear line
            
            print(f"Time: {time.strftime('%H:%M:%S')}")
            print(f"CPU Usage: {metrics['CPU']}")
            print(f"Memory:    {metrics['Memory']}")
            print(f"Disk Root: {metrics['Disk']}")
            print(f"Net Sent:  {metrics['Net_Sent']}")
            print(f"Net Recv:  {metrics['Net_Recv']}")
            
            time.sleep(interval)
            
    except KeyboardInterrupt:
        print("\nDashboard stopped.")

if __name__ == "__main__":
    # You need psutil: pip install psutil
    # run_dashboard(interval=2)
    print("Script ready. Install psutil and uncomment 'run_dashboard' to run the real-time terminal monitor.")

from flask import Flask, jsonify # pip install flask
import os
import time

app = Flask(__name__)

# --- Simple Automation Function ---
def cleanup_temp_files():
    """A placeholder for your actual cleanup automation."""
    
    # Example: Delete files in a temp folder older than 1 day
    TEMP_DIR = './temp_storage' 
    if not os.path.exists(TEMP_DIR):
        os.makedirs(TEMP_DIR)
        return 0
        
    deleted_count = 0
    now = time.time()
    for filename in os.listdir(TEMP_DIR):
        filepath = os.path.join(TEMP_DIR, filename)
        if os.path.isfile(filepath) and now - os.stat(filepath).st_mtime > (24 * 3600):
            os.remove(filepath)
            deleted_count += 1
            
    return deleted_count

# --- API Endpoint ---
@app.route('/trigger_cleanup', methods=['POST', 'GET'])
def trigger_cleanup():
    deleted = cleanup_temp_files()
    if deleted > 0:
        message = f"Cleanup successful. Deleted {deleted} old temporary files."
    else:
        message = "Cleanup ran. No old files found or temp directory was empty."
        
    # Return a JSON response
    return jsonify({"status": "success", "message": message, "files_deleted": deleted})

@app.route('/', methods=['GET'])
def index():
    return "Automation Hub Running. Visit /trigger_cleanup to run the task."

if __name__ == "__main__":
    # Run the server on the local network IP (0.0.0.0) so other devices can access it.
    # Set host='127.0.0.1' if you only want local access.
    # You need Flask: pip install Flask
    # app.run(host='0.0.0.0', port=5000, debug=False) 
    print("Script ready. Install Flask, uncomment 'app.run', and access http://127.0.0.1:5000 in your browser.")