File I/O: Read, Write & Context Managers

# Writing to a file
file = open("hello.txt", "w")
file.write("Hello, World!\n")
file.write("This is line 2.\n")
file.close()  # ⚠️ Don't forget to close!

# Reading from a file
file = open("hello.txt", "r")
content = file.read()       # reads entire file as a single string
print(content)
file.close()

# Appending to a file
file = open("hello.txt", "a")
file.write("Appended line.\n")
file.close()

# Exclusive creation – safe when you don't want to overwrite
try:
    with open("unique_file.txt", "x") as f:
        f.write("Created exclusively!\n")
except FileExistsError:
    print("File already exists – skipping.")

# Binary mode – for images, PDFs, etc.
with open("image_copy.png", "wb") as dest:
    with open("original.png", "rb") as src:
        dest.write(src.read())  # copies binary data

# ✅ The Pythonic way – no explicit close() needed
with open("data.txt", "r") as file:
    content = file.read()
    print(content)
# File is automatically closed here, even if an error occurred

# Custom context manager using a class
class ManagedFile:
    def __init__(self, filename, mode='r'):
        self.filename = filename
        self.mode = mode

    def __enter__(self):
        self.file = open(self.filename, self.mode)
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.file.close()
        if exc_type is not None:
            print(f"An error occurred: {exc_val}")
        return False  # don't suppress exceptions

with ManagedFile("log.txt", "w") as f:
    f.write("Logging with custom context manager!\n")

# 1. read() – entire file as one string (use for small files)
with open("poem.txt", "r") as f:
    whole_text = f.read()

# 2. readline() – one line at a time
with open("poem.txt", "r") as f:
    first_line = f.readline()
    second_line = f.readline()

# 3. readlines() – list of all lines (includes \n)
with open("poem.txt", "r") as f:
    all_lines = f.readlines()  # ['line1\n', 'line2\n', ...]

# 4. ✅ Best for large files – iterate directly over file object
with open("huge_log.txt", "r") as f:
    for line in f:
        process(line.strip())  # strip() removes \n and whitespace

# 5. read(n) – read n characters (or bytes in binary mode)
with open("data.txt", "r") as f:
    chunk = f.read(1024)  # read first 1024 characters

# 1. write() – writes a single string
with open("output.txt", "w") as f:
    f.write("Line 1\n")
    f.write("Line 2\n")

# 2. writelines() – writes an iterable of strings
lines = ["apple\n", "banana\n", "cherry\n"]
with open("fruits.txt", "w") as f:
    f.writelines(lines)

# 3. print() to file – convenient for formatted output
data = {"name": "Alice", "score": 95}
with open("report.txt", "w") as f:
    print(f"Student: {data['name']}", file=f)
    print(f"Score: {data['score']}", file=f)

# 4. Flushing – force write to disk immediately
with open("live_log.txt", "w", buffering=1) as f:  # line-buffered
    f.write("Processing...\n")
    f.flush()  # ensures it's written now (useful for tail -f)

import csv
import json

# ========== CSV READING ==========
with open("users.csv", "r", newline='') as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['name']} – {row['email']}")

# ========== CSV WRITING ==========
with open("export.csv", "w", newline='') as f:
    writer = csv.DictWriter(f, fieldnames=["name", "score"])
    writer.writeheader()
    writer.writerow({"name": "Alice", "score": 95})
    writer.writerow({"name": "Bob", "score": 87})

# ========== JSON READING ==========
with open("config.json", "r") as f:
    config = json.load(f)   # returns dict/list
    print(config["api_key"])

# ========== JSON WRITING ==========
data = {"users": [{"name": "Alice"}, {"name": "Bob"}]}
with open("output.json", "w") as f:
    json.dump(data, f, indent=2, ensure_ascii=False)

from pathlib import Path
import tempfile
import os

# ========== PATHLIB – modern path handling ==========
data_dir = Path("data") / "2025" / "reports"
data_dir.mkdir(parents=True, exist_ok=True)  # create dirs if needed
report_path = data_dir / "summary.txt"
report_path.write_text("Q1 Report\n", encoding="utf-8")
content = report_path.read_text(encoding="utf-8")

# ========== TEMPFILE – secure temporary files ==========
with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as tmp:
    tmp.write("Temporary data\n")
    tmp_path = tmp.name  # get the path
print(f"Temp file at: {tmp_path}")
# Process the file, then clean up
os.unlink(tmp_path)

# ========== ATOMIC WRITE – prevent partial writes ==========
def atomic_write(filepath, content):
    """Write to a temp file first, then rename atomically."""
    tmp_path = filepath + ".tmp"
    with open(tmp_path, "w", encoding="utf-8") as f:
        f.write(content)
        f.flush()
        os.fsync(f.fileno())  # force write to disk
    os.replace(tmp_path, filepath)  # atomic rename (Unix/Windows)

atomic_write("important.txt", "Critical data here.\n")

# ========== ENCODING – always specify ==========
with open("unicode_file.txt", "w", encoding="utf-8") as f:
    f.write("Café résumé – 日本語もOK\n")

def safe_read_file(filepath):
    """Read a file safely, handling common errors."""
    try:
        with open(filepath, "r", encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError:
        print(f"❌ File not found: {filepath}")
        return None
    except PermissionError:
        print(f"❌ Permission denied: {filepath}")
        return None
    except UnicodeDecodeError:
        # Try with a different encoding
        with open(filepath, "r", encoding="latin-1") as f:
            return f.read()
    except OSError as e:
        print(f"❌ OS error: {e}")
        return None

content = safe_read_file("maybe_missing.txt")