Files, pathlib & Context Managers¶

from pathlib import Path

# ── Writing ──────────────────────────────────────────────────────────────────
# "w" creates or truncates, "a" appends, "x" exclusive-create (fails if exists)
with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("first line\n")
    f.write("second line\n")
    f.writelines(["three\n", "four\n"])   # write iterable of strings

# ── Reading ───────────────────────────────────────────────────────────────────
# Read entire file at once — fine for small files (< few MB)
with open("notes.txt", encoding="utf-8") as f:
    contents = f.read()          # entire file as one string

with open("notes.txt", encoding="utf-8") as f:
    lines = f.readlines()        # list of strings, each with \n

# ── Lazy line iteration — best for large files ───────────────────────────────
# Never loads the whole file; processes one line at a time from the OS buffer
line_count = 0
with open("notes.txt", encoding="utf-8") as f:
    for line in f:               # f is its own iterator
        line = line.rstrip("\n")
        line_count += 1

# ── Binary files ─────────────────────────────────────────────────────────────
# Use "rb"/"wb" for images, PDFs, any non-text data — no encoding arg
with open("image.png", "rb") as f:
    header = f.read(8)           # read first 8 bytes
    f.seek(0)                    # rewind to start
    data = f.read()              # read all bytes

# ── pathlib one-liners ────────────────────────────────────────────────────────
Path("notes.txt").read_text(encoding="utf-8")    # entire file as str
Path("notes.txt").write_text("content\n", encoding="utf-8")  # write + close
Path("image.png").read_bytes()                   # entire file as bytes

# Implementing the protocol from scratch — instructive, though
# @contextmanager is simpler for most cases (see below)

class ManagedFile:
    def __init__(self, path, mode="r", encoding="utf-8"):
        self.path     = path
        self.mode     = mode
        self.encoding = encoding
        self.file     = None

    def __enter__(self):
        self.file = open(self.path, self.mode, encoding=self.encoding)
        return self.file          # this becomes the `as f` variable

    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()
        return False              # don't suppress exceptions

with ManagedFile("notes.txt") as f:
    content = f.read()
# f.close() guaranteed, even if f.read() raised an exception

from pathlib import Path

# Constructing paths
base = Path("data")
report = base / "reports" / "q2_2026.csv"   # OS-correct separators
config  = Path.home() / ".config" / "app" / "settings.json"
here    = Path(__file__).parent              # directory containing this script

# Decomposing paths
p = Path("/projects/app/data/report_2026.csv")
p.name         # "report_2026.csv"     — filename with extension
p.stem         # "report_2026"         — filename without extension
p.suffix       # ".csv"                — extension including dot
p.suffixes     # ['.csv']              — list (e.g., ['.tar', '.gz'])
p.parent       # Path('/projects/app/data')
p.parents[1]   # Path('/projects/app')
p.parts        # ('/', 'projects', 'app', 'data', 'report_2026.csv')

# Testing existence and type
p.exists()
p.is_file()
p.is_dir()
p.is_symlink()

# Creating directories
(base / "output").mkdir(parents=True, exist_ok=True)
# parents=True: creates intermediate dirs
# exist_ok=True: doesn't raise if already exists

# Listing files
for f in Path("data").iterdir():         # all entries in directory
    print(f.name)

for f in Path(".").glob("**/*.py"):      # recursive glob
    print(f)

for f in Path(".").rglob("*.csv"):       # rglob = recursive glob shorthand
    print(f.relative_to(Path(".")))      # path relative to base

# Reading/writing (convenience wrappers)
text = p.read_text(encoding="utf-8")
p.write_text("new content\n", encoding="utf-8")
raw  = p.read_bytes()
p.write_bytes(b"\x89PNG\r\n")

# Renaming and deleting
p.rename(p.with_suffix(".tsv"))         # change extension
p.unlink(missing_ok=True)               # delete file, OK if missing
Path("empty_dir").rmdir()               # delete empty directory

from contextlib import contextmanager, suppress
import time, tempfile, shutil
from pathlib import Path

# ── 1. Timer context manager ──────────────────────────────────────────────────
@contextmanager
def timer(label: str):
    start = time.perf_counter()
    try:
        yield                        # body runs here
    finally:                         # guaranteed even on exception
        elapsed = time.perf_counter() - start
        print(f"[{label}] {elapsed:.4f}s")

with timer("data load"):
    data = list(range(1_000_000))
# [data load] 0.0521s

# ── 2. Temporary directory that auto-cleans up ────────────────────────────────
@contextmanager
def temp_workspace():
    """Create a temp dir, yield its Path, then delete it on exit."""
    workspace = Path(tempfile.mkdtemp())
    try:
        yield workspace
    finally:
        shutil.rmtree(workspace, ignore_errors=True)

with temp_workspace() as ws:
    (ws / "output.txt").write_text("hello", encoding="utf-8")
    files = list(ws.iterdir())
    print(files)   # [PosixPath('/tmp/tmp.../output.txt')]
# workspace deleted here — always, even if exception was raised

# ── 3. Database transaction (pattern) ─────────────────────────────────────────
@contextmanager
def transaction(conn):
    """Commit on success, rollback on any exception."""
    try:
        yield conn
        conn.commit()
    except Exception:
        conn.rollback()
        raise                        # re-raise after cleanup

# with transaction(db_conn) as conn:
#     conn.execute("INSERT ...")
#     conn.execute("UPDATE ...")
# commits atomically; any error triggers rollback

# ── 4. contextlib.suppress — swallow specific exceptions ─────────────────────
with suppress(FileNotFoundError):
    Path("might_not_exist.txt").unlink()   # silently skipped if missing