Automation & scripting

import requests
import sys
from pathlib import Path

def download_latest_release(owner: str, repo: str, output_dir: str = ".") -> None:
    """Download the latest release asset from a GitHub repository."""
    url = f"https://api.github.com/repos/{owner}/{repo}/releases/latest"
    response = requests.get(url)
    res…

import re
import os
from pathlib import Path

def find_sensitive_info(log_path):
    """Scans log files for patterns like emails, IPs, API keys, and passwords."""
    patterns = {
        'Email': r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
        'IP Address': r'\b(?:\d{1,3}\.){3}\d{1,3}\b',
        'API Key'…

#!/usr/bin/env python3
import os
import subprocess

def find_zombie_processes():
    """Find zombie processes (state 'Z') running on Linux."""
    try:
        result = subprocess.run(['ps', '-eo', 'pid,stat,comm'], capture_output=True, text=True, check=True)
        zombies = []
        for line in result.stdout.stri…

import argparse

def main():
    parser = argparse.ArgumentParser(
        description="A simple CLI to process files with optional verbose mode."
    )
    parser.add_argument("filenames", nargs="+", help="Files to process")
    parser.add_argument("-v", "--verbose", action="store_true", help="Print extra details")
 …

import psutil

def find_top_memory_processes(limit=5):
    """Return top `limit` processes by memory usage (RSS)."""
    processes = []

    for proc in psutil.process_iter(['pid', 'name', 'memory_info']):
        try:
            info = proc.info
            mem = info['memory_info'].rss if info['memory_info'] else 0…

import requests
import os
import zipfile
from pathlib import Path

def download_github_release_assets(owner: str, repo: str, output_dir: str = "release_assets") -> None:
    """Downloads all assets from the latest release of a GitHub repository."""
    releases_url = f"https://api.github.com/repos/{owner}/{repo}/relea…

import json
from dataclasses import dataclass, asdict

@dataclass
class VMConfig:
    hostname: str
    cpus: int
    memory_mb: int
    ssh_key: str

def generate_cloud_init_mock(config: VMConfig) -> str:
    """Build a cloud-init user-data mock for a VM."""
    user_data = {
        "hostname": config.hostname,
    …

import subprocess
import re
import signal


def find_zombies(name_pattern):
    """Find PIDs of zombie processes matching the given pattern."""
    result = subprocess.run(["ps", "-eo", "pid,stat,comm"], capture_output=True, text=True)
    zombies = []
    for line in result.stdout.splitlines()[1:]:  # Skip header
   …

import socket

def get_a_records(hostname):
    """Fetch A records (IPv4 addresses) for a given hostname."""
    try:
        # getaddrinfo with family AF_INET restricts to IPv4 (A records)
        infos = socket.getaddrinfo(hostname, None, socket.AF_INET)
        # Each info tuple: (family, type, proto, canonname, so…

import subprocess
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

HOSTS = [
    "google.com",
    "github.com",
    "stackoverflow.com",
    "nonexistent.invalid",
    "localhost",
]

def ping_host(host: str) -> str:
    """Ping a single host and return a status string."""
    result = subp…

import os
from PIL import Image

def resize_images_in_batch(directory, output_size=(800, 600)):
    if not os.path.exists(directory):
        print(f"Directory {directory} does not exist.")
        return
    output_dir = os.path.join(directory, "resized")
    os.makedirs(output_dir, exist_ok=True)
    for filename in…

import subprocess

def ocr_image(image_path):
    command = ["tesseract", image_path, "stdout"]
    result = subprocess.run(command, capture_output=True, text=True)
    return result.stdout.strip()

if __name__ == "__main__":
    # Stub: call the actual tesseract (must be installed)
    text = ocr_image("sample.png")
…

import argparse


def main():
    parser = argparse.ArgumentParser(description="Sort numbers or words from the command line.")
    parser.add_argument("items", nargs="+", help="Items to sort (numbers or words)")
    parser.add_argument("--reverse", "-r", action="store_true", help="Sort in descending order")
    args =…

from ipaddress import ip_network

def write_hosts_deny(ip_list, output_file="hosts.deny"):
    with open(output_file, "w") as f:
        for ip in ip_list:
            try:
                ip_network(ip)
                f.write(f"ALL: {ip}\n")
            except ValueError:
                continue
    print(f"Written…

import ast
import os
import sys

def check_file(filepath):
    try:
        with open(filepath) as f:
            code = f.read()
        tree = ast.parse(code, filename=filepath)
    except SyntaxError as e:
        print(f"{filepath}: SyntaxError: {e.msg}")
        return
    
    issues = []
    for node in ast.wal…

import re
from collections import Counter

def top_ips(log_file, n=10):
    ip_pattern = re.compile(r'^(\S+)')
    ip_counts = Counter()

    with open(log_file, 'r') as f:
        for line in f:
            match = ip_pattern.match(line)
            if match:
                ip_counts[match.group(1)] += 1

    return…

import gzip
import os
import shutil
from pathlib import Path


def archive_logs(log_dir: str, max_age_days: int) -> list[str]:
    """Compress log files older than max_age_days into .gz archives.
    
    Returns a list of compressed file paths.
    """
    cutoff = time.time() - max_age_days * 86400
    compressed = …

#!/usr/bin/env python3
"""Mock script to demonstrate disk partition resize logic."""
import json
from dataclasses import dataclass
from typing import Dict


@dataclass
class Partition:
    name: str
    size_gb: int
    mount_point: str

    def to_dict(self) -> Dict[str, object]:
        return {
            "name": …