18 — File I/O & Serialization

with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("first line\n")
    f.write("second line\n")

with open("notes.txt", "r", encoding="utf-8") as f:
    content = f.read()
print(content)
# first line
# second line

with open("notes.txt", "a", encoding="utf-8") as f:
    f.write("appended line\n")

# RISKY — if write() or any code between open/close raises, close() never runs
f = open("data.txt", "w")
f.write("data")
process_data()   # if this raises, the file is never closed — buffered writes may be lost
f.close()

# CORRECT — guaranteed cleanup regardless of exceptions
with open("data.txt", "w") as f:
    f.write("data")
    process_data()

# Whole file at once — fine for small/medium files, dangerous for huge ones (loads it ALL into memory)
with open("small.txt", encoding="utf-8") as f:
    content = f.read()

# Line by line — memory-efficient, the idiomatic way to process large text files (see chapter 09)
with open("huge.log", encoding="utf-8") as f:
    for line in f:                 # the file object IS an iterator over lines
        if "ERROR" in line:
            print(line.strip())

# All lines as a list — loads everything, but gives you len()/indexing
with open("small.txt", encoding="utf-8") as f:
    lines = f.readlines()

# Fixed-size chunks — for binary data or streaming processing
with open("large.bin", "rb") as f:
    while chunk := f.read(8192):     # walrus operator (chapter 03) — read until EOF returns b""
        process_chunk(chunk)

from pathlib import Path

config_dir = Path.home() / ".config" / "myapp"    # `/` is OVERLOADED to join paths — cross-platform!
config_file = config_dir / "settings.json"

config_dir.mkdir(parents=True, exist_ok=True)      # like `mkdir -p`
config_file.write_text('{"debug": true}', encoding="utf-8")

print(config_file.exists())      # True
print(config_file.name)            # "settings.json"
print(config_file.stem)              # "settings"
print(config_file.suffix)              # ".json"
print(config_file.parent)                # .../.config/myapp

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

content = config_file.read_text(encoding="utf-8")
print(content)   # {"debug": true}

import json

data = {"name": "Ada", "age": 36, "active": True, "tags": ["math", "computing"]}

json_string = json.dumps(data, indent=2)
print(json_string)
# {
#   "name": "Ada",
#   "age": 36,
#   "active": true,
#   "tags": [
#     "math",
#     "computing"
#   ]
# }

parsed = json.loads(json_string)
print(parsed["name"])   # "Ada"
print(parsed == data)     # True

with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, indent=2)

with open("data.json", encoding="utf-8") as f:
    loaded = json.load(f)

data = {"coords": (1, 2), "tags": {"a", "b"}}
# json.dumps(data)   # TypeError: Object of type set is not JSON serializable

data_fixed = {"coords": [1, 2], "tags": list({"a", "b"})}
print(json.dumps(data_fixed))   # {"coords": [1, 2], "tags": [...]}  — order of set->list is not guaranteed!

# Round-tripping a tuple through JSON silently turns it into a list — JSON has no tuple type at all
round_tripped = json.loads(json.dumps({"coords": (1, 2)}))
print(round_tripped)                # {'coords': [1, 2]}
print(type(round_tripped["coords"]))  # <class 'list'> — NOT tuple!

from datetime import datetime, date

def json_default(obj):
    if isinstance(obj, (datetime, date)):
        return obj.isoformat()
    raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")

payload = {"created_at": datetime(2024, 1, 15, 10, 30)}
print(json.dumps(payload, default=json_default))
# {"created_at": "2024-01-15T10:30:00"}

import pickle

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

p = Point(3, 4)

with open("point.pkl", "wb") as f:      # ALWAYS binary mode for pickle
    pickle.dump(p, f)

with open("point.pkl", "rb") as f:
    loaded = pickle.load(f)
print(loaded.x, loaded.y)   # 3 4 — full object, including class identity, restored

import csv

rows = [
    {"name": "Ada", "role": "Mathematician"},
    {"name": "Grace", "role": "Rear Admiral"},
]

with open("people.csv", "w", newline="", encoding="utf-8") as f:   # newline="" is REQUIRED on all platforms
    writer = csv.DictWriter(f, fieldnames=["name", "role"])
    writer.writeheader()
    writer.writerows(rows)

with open("people.csv", newline="", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row)   # OrderedDict-like access: row["name"], row["role"]

# WRONG — mixing text mode with binary data, or vice versa, raises TypeError immediately...
with open("data.bin", "rb") as f:
    data = f.read()
# f.write("text")   # TypeError: a bytes-like object is required, not 'str'

# ...but the MORE DANGEROUS mistake is omitting encoding= on text mode, which doesn't error —
# it silently uses the OS's default encoding, which varies by platform and locale
with open("notes.txt", "w") as f:      # no encoding= specified!
    f.write("café")                       # writes using locale.getpreferredencoding(), NOT guaranteed UTF-8

# On a system with a non-UTF-8 default locale, or when the file is later read on a DIFFERENT
# system, this can raise UnicodeDecodeError or silently produce mojibake (garbled text)

# Explicit encode/decode when working directly with bytes
text = "héllo wörld"
encoded = text.encode("utf-8")
print(encoded)                 # b'h\xc3\xa9llo w\xc3\xb6rld'
print(len(text), len(encoded))   # 11 13 — multi-byte characters make byte length > character length

decoded = encoded.decode("utf-8")
print(decoded == text)   # True

# decoding with the WRONG encoding produces garbage or raises
# encoded.decode("ascii")   # UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3
print(encoded.decode("latin-1"))   # "héllo wörld" — decodes WITHOUT error, but WRONG text (mojibake)

import tempfile

with tempfile.NamedTemporaryFile(mode="w", suffix=".txt", delete=True, encoding="utf-8") as tmp:
    tmp.write("scratch data")
    tmp.flush()
    print(tmp.name)             # the OS-assigned unique path
# file is automatically deleted here, when the `with` block exits

with tempfile.TemporaryDirectory() as tmpdir:
    print(tmpdir)                  # a fresh, unique directory
    # ... write multiple files into it ...
# entire directory tree is removed automatically on exit

def save_comment(comment, path="comments.log"):
    with open(path, "a") as f:
        f.write(comment + "\n")

def load_comments(path="comments.log"):
    with open(path) as f:
        return f.readlines()

save_comment("Café con leche, por favor")
comments = load_comments()
print(comments)