Python File Handling — 'w' Mode Truncates on Open

# Scenario: parse a server log file and count how many lines are ERROR level

log_file_path = "server.log"

# Create a sample log file to work with so this script is self-contained
with open(log_file_path, "w", encoding="utf-8") as log_file:
    log_file.write("INFO  2024-06-01 08:00:01 Server started\n")
    log_file.write("INFO  2024-06-01 08:01:15 Request received from 192.168.1.10\n")
    log_file.write("ERROR 2024-06-01 08:01:16 Database connection timeout\n")
    log_file.write("INFO  2024-06-01 08:02:00 Retrying connection\n")
    log_file.write("ERROR 2024-06-01 08:02:05 Max retries exceeded\n")
    log_file.write("INFO  2024-06-01 08:02:06 Falling back to cache\n")

error_count = 0
error_lines = []

# The 'with' block guarantees the file is closed when we're done,
# even if an exception is raised inside the block.
with open(log_file_path, "r", encoding="utf-8") as log_file:
    # Iterating the file object directly reads ONE line at a time —
    # this works correctly even for a 10 GB log file because Python
    # never loads the whole thing into memory at once.
    for line in log_file:
        stripped_line = line.strip()  # remove trailing newline characters
        if stripped_line.startswith("ERROR"):
            error_count += 1
            error_lines.append(stripped_line)

print(f"Total ERROR lines found: {error_count}")
print("\nError details:")
for error in error_lines:
    print(f"  -> {error}")

import datetime

activity_log_path = "user_activity.log"

def log_activity(username: str, action: str) -> None:
    """Append a timestamped activity record to the log file.

    We use 'a' mode so that every call adds to the existing log
    rather than overwriting it. This function is safe to call
    from multiple places in a long-running application.
    """
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    # Build the full log entry as a single string with its own newline
    log_entry = f"[{timestamp}] USER={username} ACTION={action}\n"

    with open(activity_log_path, "a", encoding="utf-8") as activity_log:
        activity_log.write(log_entry)  # 'a' mode: cursor is always at end of file

def generate_daily_report(report_date: str, summary_lines: list[str]) -> None:
    """Write a fresh daily report, replacing any previous report for the same name.

    We intentionally use 'w' mode here because the report is always
    regenerated from scratch — old content should not carry over.
    """
    report_path = f"report_{report_date}.txt"
    header = f"=== Daily Report for {report_date} ===\n\n"

    with open(report_path, "w", encoding="utf-8") as report_file:
        report_file.write(header)
        # writelines() writes each string as-is — no automatic newlines added
        # so we ensure each summary line already ends with '\n'
        report_file.writelines(line + "\n" for line in summary_lines)

    print(f"Report saved to {report_path}")

# Simulate three user events arriving over time
log_activity("alice", "LOGIN")
log_activity("bob", "VIEWED_DASHBOARD")
log_activity("alice", "EXPORTED_CSV")

# Read back the log to confirm all three entries were preserved
print("--- Current activity log ---")
with open(activity_log_path, "r", encoding="utf-8") as activity_log:
    print(activity_log.read())

# Generate a report (uses 'w' mode — intentionally fresh each time)
generate_daily_report(
    report_date="2024-06-01",
    summary_lines=[
        "Total logins: 1",
        "Total page views: 1",
        "Total exports: 1"
    ]
)

import json
from pathlib import Path

DEFAULT_CONFIG = {
    "theme": "dark",
    "language": "en",
    "auto_save_interval_seconds": 30
}

CONFIG_PATH = Path("app_data") / "config.json"

def load_config() -> dict:
    """Load config from disk. Returns defaults if the file doesn't exist yet.

    Uses EAFP style: try the operation, handle the specific failure.
    This avoids the race condition that os.path.exists() creates.
    """
    try:
        with open(CONFIG_PATH, "r", encoding="utf-8") as config_file:
            loaded_config = json.load(config_file)
            print(f"Config loaded from {CONFIG_PATH}")
            return loaded_config

    except FileNotFoundError:
        # This is expected on first run — not an error, just a first boot
        print(f"No config file found at {CONFIG_PATH}. Using defaults.")
        return DEFAULT_CONFIG.copy()

    except json.JSONDecodeError as parse_error:
        # The file exists but is malformed — this IS an error worth reporting
        print(f"WARNING: Config file is corrupted ({parse_error}). Using defaults.")
        return DEFAULT_CONFIG.copy()

    except PermissionError:
        # We can't read the file — fail loudly, don't silently use defaults
        raise RuntimeError(
            f"Cannot read config at {CONFIG_PATH}. Check file permissions."
        )

def save_config(config: dict) -> None:
    """Save config to disk, creating the directory structure if it doesn't exist."""
    # mkdir with parents=True creates 'app_data/' if it's missing
    # exist_ok=True means no error if the directory is already there
    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)

    with open(CONFIG_PATH, "w", encoding="utf-8") as config_file:
        # indent=2 makes the JSON human-readable — important for config files
        json.dump(config, config_file, indent=2)
        print(f"Config saved to {CONFIG_PATH}")

# First load — file doesn't exist yet
current_config = load_config()
print(f"Theme: {current_config['theme']}")

# User changes a setting
current_config["theme"] = "light"
save_config(current_config)

# Second load — now reads from disk
current_config = load_config()
print(f"Theme after reload: {current_config['theme']}")

from pathlib import Path
import shutil

# Scenario: scan a 'downloads' folder and copy image files into an 'images' archive.
# This pattern works identically on Windows, macOS and Linux because pathlib
# handles the slash vs backslash difference for you automatically.

DOWNLOADS_DIR = Path("sample_downloads")
IMAGES_ARCHIVE_DIR = Path("organised") / "images"

# Create sample directory with mixed file types so the script is self-contained
DOWNLOADS_DIR.mkdir(exist_ok=True)
(DOWNLOADS_DIR / "holiday_photo.jpg").write_bytes(b"\xff\xd8\xff" + b"\x00" * 10)
(DOWNLOADS_DIR / "budget.xlsx").write_bytes(b"PK\x03\x04" + b"\x00" * 10)
(DOWNLOADS_DIR / "profile_pic.png").write_bytes(b"\x89PNG" + b"\x00" * 10)
(DOWNLOADS_DIR / "notes.txt").write_text("Some text notes", encoding="utf-8")
(DOWNLOADS_DIR / "logo.jpg").write_bytes(b"\xff\xd8\xff" + b"\x00" * 10)

IMAGES_ARCHIVE_DIR.mkdir(parents=True, exist_ok=True)

image_extensions = {".jpg", ".jpeg", ".png", ".gif", ".webp"}
copy_count = 0

# Path.iterdir() yields Path objects for every item in the directory —
# no string path manipulation needed, no os.path.join() required.
for file_path in DOWNLOADS_DIR.iterdir():
    # .is_file() filters out subdirectories
    # .suffix gives the file extension including the dot, e.g. '.jpg'
    if file_path.is_file() and file_path.suffix.lower() in image_extensions:
        destination = IMAGES_ARCHIVE_DIR / file_path.name

        # shutil.copy2 copies file content AND metadata (timestamps etc.)
        shutil.copy2(file_path, destination)
        copy_count += 1
        print(f"  Copied: {file_path.name} -> {destination}")

print(f"\nDone. {copy_count} image file(s) archived to {IMAGES_ARCHIVE_DIR}")

# Demonstrate reading binary content back
for image_path in IMAGES_ARCHIVE_DIR.glob("*.jpg"):
    # 'rb' mode returns raw bytes — no encoding involved
    with image_path.open("rb") as image_file:
        first_bytes = image_file.read(3)  # JPEG magic bytes are FF D8 FF
        print(f"  {image_path.name} magic bytes: {first_bytes.hex().upper()}")

import csv
from pathlib import Path

# Scenario: read a messy CSV exported from Excel (has BOM, inconsistent quotes)
# and write a clean UTF-8 CSV with standard formatting.

input_path = Path("sales_export.csv")
output_path = Path("sales_cleaned.csv")

# Create a sample 'messy' CSV file for demonstration
with open(input_path, "w", encoding="utf-8-sig") as f:
    f.write("\ufeffProduct,Price,Quantity\r\n")
    f.write('Widget A,"$12.50",3\r\n')
    f.write('Widget B,"$24.99",1\r\n')
    f.write('Widget C,"$5.00",10\r\n')

def clean_price(price_str: str) -> float:
    """Remove currency symbols and whitespace, return float."""
    return float(price_str.replace("$", "").replace(",", "").strip())

# Open with newline='' — critical for csv module portability
with open(input_path, "r", encoding="utf-8-sig", newline='') as infile, \
     open(output_path, "w", encoding="utf-8", newline='') as outfile:

    reader = csv.DictReader(infile)
    fieldnames = reader.fieldnames
    writer = csv.DictWriter(outfile, fieldnames=fieldnames)
    writer.writeheader()

    for row in reader:
        # Clean price field
        row["Price"] = f'{clean_price(row["Price"]):.2f}'
        writer.writerow(row)

print(f"Cleaned CSV written to {output_path}")

# Verify output
with open(output_path, "r", encoding="utf-8") as f:
    print(f.read())