📂 Lesson 8.1: Reading and Writing Files

import os
from pathlib import Path  # Modern Python — recommended!

# --- Absolute vs Relative ---
absolute = "/home/ray/projects/data.txt"
relative = "data/scores.txt"  # Relative to where you run the script

# --- The pathlib way (modern Python 3.4+) ---
# Build paths that work on ANY operating system:
data_dir = Path("data")
scores_file = data_dir / "scores.txt"   # Uses / operator!
print(scores_file)  # data/scores.txt (or data\scores.txt on Windows)

# Useful Path methods:
p = Path("data/reports/q4.txt")
print(p.name)       # "q4.txt"         — filename
print(p.stem)       # "q4"             — filename without extension
print(p.suffix)     # ".txt"           — file extension
print(p.parent)     # "data/reports"   — parent directory
print(p.exists())   # True or False    — does the file exist?
print(p.is_file())  # True or False    — is it a file (not directory)?

# Get current working directory:
print(Path.cwd())   # e.g., /home/ray/projects

# --- The os.path way (older but still common) ---
full_path = os.path.join("data", "scores.txt")  # Cross-platform join
print(os.path.exists(full_path))   # True/False
print(os.path.basename(full_path)) # "scores.txt"
print(os.path.dirname(full_path))  # "data"

// Node.js — the 'path' module handles cross-platform paths
const path = require("path");
const fs = require("fs");

// --- Absolute vs Relative ---
let absolute = "/home/ray/projects/data.txt";
let relative = "data/scores.txt";  // Relative to where you run node

// --- Building paths safely ---
// ALWAYS use path.join() — never concatenate strings with / or \
let scoresFile = path.join("data", "scores.txt");
console.log(scoresFile);  // "data/scores.txt" (or "data\scores.txt" on Windows)

// Useful path methods:
let p = path.join("data", "reports", "q4.txt");
console.log(path.basename(p));           // "q4.txt"
console.log(path.basename(p, ".txt"));   // "q4" (without extension)
console.log(path.extname(p));            // ".txt"
console.log(path.dirname(p));            // "data/reports"

// Check if file exists:
console.log(fs.existsSync(scoresFile));  // true or false

// Get current working directory:
console.log(process.cwd());  // e.g., /home/ray/projects

// Get absolute path from relative:
console.log(path.resolve("data", "scores.txt"));
// → /home/ray/projects/data/scores.txt

// __dirname = directory of the CURRENT script file
// __filename = full path of the CURRENT script file
console.log(__dirname);   // /home/ray/projects
console.log(__filename);  // /home/ray/projects/app.js

using System.IO;

// --- Absolute vs Relative ---
string absolute = @"C:\Users\ray\projects\data.txt";  // @ = verbatim string
string relative = "data/scores.txt";  // Relative to working directory

// --- Building paths safely ---
// ALWAYS use Path.Combine() — never concatenate with + and slashes
string scoresFile = Path.Combine("data", "scores.txt");
Console.WriteLine(scoresFile);  // data\scores.txt (Windows) or data/scores.txt

// Useful Path methods:
string p = Path.Combine("data", "reports", "q4.txt");
Console.WriteLine(Path.GetFileName(p));           // "q4.txt"
Console.WriteLine(Path.GetFileNameWithoutExtension(p)); // "q4"
Console.WriteLine(Path.GetExtension(p));          // ".txt"
Console.WriteLine(Path.GetDirectoryName(p));      // "data/reports"

// Check if file/directory exists:
Console.WriteLine(File.Exists(scoresFile));       // True/False
Console.WriteLine(Directory.Exists("data"));      // True/False

// Get current working directory:
Console.WriteLine(Directory.GetCurrentDirectory());

// Get absolute path from relative:
Console.WriteLine(Path.GetFullPath("data/scores.txt"));

// Cross-platform separator:
Console.WriteLine(Path.DirectorySeparatorChar);   // \ on Windows, / on Mac/Linux

# --- Method 1: with statement (recommended!) ---
# 'with' automatically closes the file when the block ends
with open("data/greeting.txt", "r") as file:
    content = file.read()          # Read entire file as one string
    print(content)

# After the 'with' block, file is automatically closed — no cleanup needed!

# --- Method 2: read into a list of lines ---
with open("data/scores.txt", "r") as file:
    lines = file.readlines()       # List of strings, one per line
    print(lines)
    # ['Alice,95\n', 'Bob,87\n', 'Charlie,72\n']
    # Note: each line includes the \n newline character!

# Strip the newlines:
with open("data/scores.txt", "r") as file:
    lines = [line.strip() for line in file.readlines()]
    print(lines)
    # ['Alice,95', 'Bob,87', 'Charlie,72']

# --- Method 3: Pathlib (cleanest for small files) ---
from pathlib import Path
content = Path("data/greeting.txt").read_text()
print(content)

const fs = require("fs");

// --- Method 1: Synchronous (blocking) ---
// Simple and predictable — good for scripts and learning
let content = fs.readFileSync("data/greeting.txt", "utf-8");
console.log(content);

// --- Method 2: Read as array of lines ---
let lines = fs.readFileSync("data/scores.txt", "utf-8")
    .split("\n")           // Split into lines
    .filter(line => line); // Remove empty lines
console.log(lines);
// ['Alice,95', 'Bob,87', 'Charlie,72']

// --- Method 3: Asynchronous with callback ---
// Non-blocking — good for servers and performance
fs.readFile("data/greeting.txt", "utf-8", (err, data) => {
    if (err) {
        console.error("Error reading file:", err.message);
        return;
    }
    console.log(data);
});

// --- Method 4: Async/Await (modern, recommended) ---
const fsPromises = require("fs").promises;

async function readGreeting() {
    let content = await fsPromises.readFile("data/greeting.txt", "utf-8");
    console.log(content);
}
readGreeting();

using System.IO;

// --- Method 1: Read entire file as one string ---
string content = File.ReadAllText("data/greeting.txt");
Console.WriteLine(content);

// --- Method 2: Read as array of lines ---
string[] lines = File.ReadAllLines("data/scores.txt");
foreach (string line in lines)
    Console.WriteLine(line);
// Alice,95
// Bob,87
// Charlie,72

// --- Method 3: Async version (for larger files or UI apps) ---
string asyncContent = await File.ReadAllTextAsync("data/greeting.txt");

// --- Method 4: StreamReader (for very large files) ---
using (StreamReader reader = new StreamReader("data/big_file.txt"))
{
    string? line;
    while ((line = reader.ReadLine()) != null)
    {
        Console.WriteLine(line);   // Process one line at a time
    }
}  // StreamReader automatically closed here

# The file object itself is iterable — loop over it directly!
with open("data/large_log.txt", "r") as file:
    for line_number, line in enumerate(file, start=1):
        line = line.strip()              # Remove trailing \n
        if "ERROR" in line:
            print(f"Line {line_number}: {line}")

# This reads ONE line at a time — works for gigabyte-sized files!
# The file is never fully loaded into memory.

const fs = require("fs");
const readline = require("readline");

// Create a line reader from a file stream
const fileStream = fs.createReadStream("data/large_log.txt");
const rl = readline.createInterface({ input: fileStream });

let lineNumber = 0;
rl.on("line", (line) => {
    lineNumber++;
    if (line.includes("ERROR")) {
        console.log(`Line ${lineNumber}: ${line}`);
    }
});

rl.on("close", () => {
    console.log("Done reading file.");
});

// For modern async/await style:
// const rl = readline.createInterface({ input: fileStream });
// for await (const line of rl) { ... }

// StreamReader reads line by line — ideal for large files
int lineNumber = 0;
using (StreamReader reader = new StreamReader("data/large_log.txt"))
{
    string? line;
    while ((line = reader.ReadLine()) != null)
    {
        lineNumber++;
        if (line.Contains("ERROR"))
            Console.WriteLine($"Line {lineNumber}: {line}");
    }
}

// Or with the modern File.ReadLines() which is lazy (one at a time):
foreach (string line in File.ReadLines("data/large_log.txt"))
{
    if (line.Contains("ERROR"))
        Console.WriteLine(line);
}
// File.ReadLines() is lazy — it reads on demand, unlike ReadAllLines()

# --- Write: creates file or OVERWRITES if it exists ---
with open("output/report.txt", "w") as file:
    file.write("Sales Report\n")
    file.write("============\n\n")
    file.write("Q1: $45,000\n")
    file.write("Q2: $52,000\n")

# --- Write multiple lines at once ---
lines = ["Alice: 95\n", "Bob: 87\n", "Charlie: 72\n"]
with open("output/grades.txt", "w") as file:
    file.writelines(lines)  # Note: writelines does NOT add \n automatically!

# --- Pathlib shortcut ---
from pathlib import Path
Path("output/quick.txt").write_text("Hello from Pathlib!\n")

# --- Using print() to write to a file ---
with open("output/log.txt", "w") as file:
    print("Starting process...", file=file)    # print to file!
    print(f"Result: {42}", file=file)
    print("Done.", file=file)

# --- DANGER: "w" mode erases existing content! ---
# This is the #1 file-writing mistake:
with open("important_data.txt", "w") as file:   # ⚠️ Erases everything!
    file.write("Oops, old data is gone forever")

const fs = require("fs");

// --- Write: creates file or OVERWRITES if it exists ---
fs.writeFileSync("output/report.txt",
    "Sales Report\n" +
    "============\n\n" +
    "Q1: $45,000\n" +
    "Q2: $52,000\n"
);

// --- Write from an array of lines ---
let lines = ["Alice: 95", "Bob: 87", "Charlie: 72"];
fs.writeFileSync("output/grades.txt", lines.join("\n") + "\n");

// --- Async version (recommended for production) ---
const fsPromises = require("fs").promises;

async function writeReport() {
    await fsPromises.writeFile("output/report.txt", "Sales Report\n");
    console.log("Report written!");
}
writeReport();

// --- DANGER: writeFileSync OVERWRITES by default! ---
fs.writeFileSync("important_data.txt", "Oops, old data is gone!");

// To create a file ONLY if it doesn't exist:
try {
    fs.writeFileSync("output/safe.txt", "New content", { flag: "wx" });
} catch (err) {
    if (err.code === "EEXIST") {
        console.log("File already exists — not overwriting.");
    }
}

using System.IO;

// --- Write: creates file or OVERWRITES if it exists ---
File.WriteAllText("output/report.txt",
    "Sales Report\n" +
    "============\n\n" +
    "Q1: $45,000\n" +
    "Q2: $52,000\n"
);

// --- Write from an array of lines ---
string[] lines = { "Alice: 95", "Bob: 87", "Charlie: 72" };
File.WriteAllLines("output/grades.txt", lines);
// WriteAllLines automatically adds newlines between entries!

// --- Async version ---
await File.WriteAllTextAsync("output/report.txt", "Sales Report\n");

// --- StreamWriter for more control ---
using (StreamWriter writer = new StreamWriter("output/log.txt"))
{
    writer.WriteLine("Starting process...");    // Adds newline
    writer.WriteLine($"Result: {42}");
    writer.Write("No newline after this");      // No newline
}

// --- DANGER: WriteAllText OVERWRITES by default! ---
File.WriteAllText("important_data.txt", "Oops, old data is gone!");

// To safely avoid overwriting:
if (!File.Exists("output/safe.txt"))
{
    File.WriteAllText("output/safe.txt", "New content");
}
else
{
    Console.WriteLine("File already exists — not overwriting.");
}

from datetime import datetime

# --- Append mode: "a" ---
# If the file doesn't exist, it creates it.
# If it does exist, new content goes at the END.

def log_event(message):
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    with open("app.log", "a") as file:
        file.write(f"[{timestamp}] {message}\n")

log_event("Application started")
log_event("User logged in: alice")
log_event("Processing order #1234")

# app.log now contains:
# [2026-04-13 10:30:01] Application started
# [2026-04-13 10:30:01] User logged in: alice
# [2026-04-13 10:30:01] Processing order #1234

# Run the program again — new entries are ADDED, old ones stay!

const fs = require("fs");

// --- Append with appendFileSync ---
function logEvent(message) {
    let timestamp = new Date().toISOString().slice(0, 19).replace("T", " ");
    fs.appendFileSync("app.log", `[${timestamp}] ${message}\n`);
}

logEvent("Application started");
logEvent("User logged in: alice");
logEvent("Processing order #1234");

// --- Or use the flag option with writeFileSync ---
fs.writeFileSync("app.log", "Extra line\n", { flag: "a" });
// flag: "a" = append mode

// --- Async version ---
const fsPromises = require("fs").promises;

async function logEventAsync(message) {
    let timestamp = new Date().toISOString().slice(0, 19).replace("T", " ");
    await fsPromises.appendFile("app.log", `[${timestamp}] ${message}\n`);
}
logEventAsync("Async log entry");

using System.IO;

// --- Append with File.AppendAllText ---
void LogEvent(string message)
{
    string timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
    File.AppendAllText("app.log", $"[{timestamp}] {message}\n");
}

LogEvent("Application started");
LogEvent("User logged in: alice");
LogEvent("Processing order #1234");

// --- Append multiple lines ---
string[] newEntries = { "Entry A", "Entry B", "Entry C" };
File.AppendAllLines("app.log", newEntries);  // Each gets a newline

// --- StreamWriter in append mode ---
using (StreamWriter writer = new StreamWriter("app.log", append: true))
{
    writer.WriteLine("StreamWriter append entry");
}

// --- Async version ---
await File.AppendAllTextAsync("app.log", "Async entry\n");

# ❌ UNSAFE: if an error occurs, the file might not close
file = open("data.txt", "r")
content = file.read()     # What if this line throws an error?
file.close()              # This might never run!

# ✅ SAFE: 'with' guarantees the file closes, even if an error occurs
with open("data.txt", "r") as file:
    content = file.read()
# file.close() is called automatically — even if an exception is thrown!

# Why? The 'with' statement calls __enter__() on entry and
# __exit__() on exit — __exit__() always closes the file.

# ✅ ALSO SAFE: try/finally (but 'with' is preferred)
file = open("data.txt", "r")
try:
    content = file.read()
finally:
    file.close()  # Runs even if an exception occurs

# Multiple files at once:
with open("input.txt", "r") as infile, open("output.txt", "w") as outfile:
    for line in infile:
        outfile.write(line.upper())  # Copy with transformation

const fs = require("fs");

// For readFileSync/writeFileSync, Node.js handles
// open and close internally — no explicit cleanup needed:
let content = fs.readFileSync("data.txt", "utf-8");  // Opens, reads, closes

// But for streams (large files), you manage the lifecycle:

// ❌ UNSAFE: file descriptor might leak on error
const fd = fs.openSync("data.txt", "r");
const buffer = Buffer.alloc(1024);
fs.readSync(fd, buffer);     // What if this throws?
fs.closeSync(fd);             // Might never run!

// ✅ SAFE: try/finally ensures cleanup
const fd2 = fs.openSync("data.txt", "r");
try {
    const buffer2 = Buffer.alloc(1024);
    fs.readSync(fd2, buffer2);
} finally {
    fs.closeSync(fd2);        // Always runs!
}

// ✅ BEST: Use high-level APIs that handle cleanup for you
// readFileSync, writeFileSync, appendFileSync — all safe
// For streams, attach error handlers:
const stream = fs.createReadStream("data.txt");
stream.on("error", (err) => {
    console.error("Stream error:", err.message);
    // Stream closes automatically on error
});

using System.IO;

// ❌ UNSAFE: if an error occurs, reader might not close
StreamReader reader = new StreamReader("data.txt");
string content = reader.ReadToEnd();    // What if this throws?
reader.Close();                          // Might never run!

// ✅ SAFE: 'using' guarantees Dispose() is called (which closes the file)
using (StreamReader safeReader = new StreamReader("data.txt"))
{
    string safeContent = safeReader.ReadToEnd();
}  // safeReader.Dispose() called automatically — even on exception!

// ✅ MODERN C# 8+: using declaration (no braces needed)
using StreamReader modernReader = new StreamReader("data.txt");
string modernContent = modernReader.ReadToEnd();
// Disposed when modernReader goes out of scope (end of method/block)

// ✅ SIMPLEST: Use File.ReadAllText / WriteAllText
// These handle open + read/write + close internally:
string easy = File.ReadAllText("data.txt");  // Safe by design
File.WriteAllText("output.txt", "Safe!");    // Safe by design

// Multiple files:
using StreamReader input = new StreamReader("input.txt");
using StreamWriter output = new StreamWriter("output.txt");
string? line;
while ((line = input.ReadLine()) != null)
{
    output.WriteLine(line.ToUpper());  // Copy with transformation
}

import csv

# --- Reading CSV ---
with open("students.csv", "r") as file:
    reader = csv.reader(file)
    header = next(reader)           # First row is the header
    print(f"Columns: {header}")     # ['name', 'score', 'grade']

    for row in reader:
        name, score, grade = row    # Unpack each row
        print(f"{name} scored {score} ({grade})")

# --- Reading CSV as dictionaries (recommended!) ---
with open("students.csv", "r") as file:
    reader = csv.DictReader(file)   # Uses header row as keys
    for row in reader:
        print(f"{row['name']} scored {row['score']} ({row['grade']})")
        # row is {'name': 'Alice', 'score': '95', 'grade': 'A'}
        # Note: all values are STRINGS — convert numbers yourself!

# --- Writing CSV ---
students = [
    {"name": "Alice", "score": 95, "grade": "A"},
    {"name": "Bob", "score": 87, "grade": "B"},
    {"name": "Charlie", "score": 72, "grade": "C"},
]

with open("output.csv", "w", newline="") as file:
    writer = csv.DictWriter(file, fieldnames=["name", "score", "grade"])
    writer.writeheader()             # Write the header row
    writer.writerows(students)       # Write all data rows

const fs = require("fs");

// --- Reading CSV (manual parsing for simple cases) ---
let csvText = fs.readFileSync("students.csv", "utf-8");
let lines = csvText.trim().split("\n");
let header = lines[0].split(",");       // ['name', 'score', 'grade']

let students = lines.slice(1).map(line => {
    let values = line.split(",");
    return {
        name: values[0],
        score: parseInt(values[1]),     // Convert to number!
        grade: values[2],
    };
});

console.log(students);
// [{name: 'Alice', score: 95, grade: 'A'}, ...]

// --- Writing CSV ---
let outputStudents = [
    { name: "Alice", score: 95, grade: "A" },
    { name: "Bob", score: 87, grade: "B" },
    { name: "Charlie", score: 72, grade: "C" },
];

let csvHeader = "name,score,grade\n";
let csvRows = outputStudents
    .map(s => `${s.name},${s.score},${s.grade}`)
    .join("\n");
fs.writeFileSync("output.csv", csvHeader + csvRows + "\n");

// ⚠️ This simple approach breaks if values contain commas!
// "Smith, Jr.",95,A → splits wrong!
// For real CSV parsing, use a library like 'csv-parse' or 'papaparse':
// npm install csv-parse

using System.IO;

// --- Reading CSV (manual parsing for simple cases) ---
string[] lines = File.ReadAllLines("students.csv");
string[] header = lines[0].Split(",");  // ["name", "score", "grade"]

var students = new List<Dictionary<string, string>>();
for (int i = 1; i < lines.Length; i++)
{
    string[] values = lines[i].Split(",");
    students.Add(new Dictionary<string, string>
    {
        ["name"] = values[0],
        ["score"] = values[1],
        ["grade"] = values[2],
    });
}

foreach (var student in students)
    Console.WriteLine($"{student["name"]} scored {student["score"]}");

// --- Writing CSV ---
var outputLines = new List<string> { "name,score,grade" };
outputLines.Add("Alice,95,A");
outputLines.Add("Bob,87,B");
outputLines.Add("Charlie,72,C");
File.WriteAllLines("output.csv", outputLines);

// ⚠️ Manual parsing breaks with commas in values!
// For production CSV handling, use a library like CsvHelper:
// dotnet add package CsvHelper

# --- Handle specific file errors ---
try:
    with open("missing_file.txt", "r") as file:
        content = file.read()
except FileNotFoundError:
    print("Error: File not found. Check the path and filename.")
except PermissionError:
    print("Error: No permission to read this file.")
except UnicodeDecodeError:
    print("Error: File is not valid text (might be binary).")
except IsADirectoryError:
    print("Error: That's a directory, not a file.")
except OSError as e:
    print(f"Error: Unexpected file error — {e}")

# --- Check before opening ---
from pathlib import Path

file_path = Path("data/config.txt")

if not file_path.exists():
    print(f"File not found: {file_path}")
elif not file_path.is_file():
    print(f"Not a file: {file_path}")
else:
    content = file_path.read_text()
    print(f"Read {len(content)} characters.")

# --- Create directories if they don't exist ---
output_dir = Path("output/reports/2026")
output_dir.mkdir(parents=True, exist_ok=True)  # Creates all needed folders
Path(output_dir / "q1.txt").write_text("Q1 Report")

# --- Specifying encoding (important!) ---
# Default encoding varies by OS! Always be explicit:
with open("data.txt", "r", encoding="utf-8") as file:
    content = file.read()

with open("output.txt", "w", encoding="utf-8") as file:
    file.write("Héllo Wörld! 你好世界")

const fs = require("fs");
const path = require("path");

// --- Handle specific file errors ---
try {
    let content = fs.readFileSync("missing_file.txt", "utf-8");
} catch (err) {
    switch (err.code) {
        case "ENOENT":
            console.log("Error: File not found. Check the path.");
            break;
        case "EACCES":
            console.log("Error: No permission to read this file.");
            break;
        case "EISDIR":
            console.log("Error: That's a directory, not a file.");
            break;
        default:
            console.log(`Error: ${err.message}`);
    }
}

// --- Check before opening ---
let filePath = "data/config.txt";

if (!fs.existsSync(filePath)) {
    console.log(`File not found: ${filePath}`);
} else {
    let stats = fs.statSync(filePath);
    if (!stats.isFile()) {
        console.log(`Not a file: ${filePath}`);
    } else {
        let content = fs.readFileSync(filePath, "utf-8");
        console.log(`Read ${content.length} characters.`);
    }
}

// --- Create directories if they don't exist ---
let outputDir = path.join("output", "reports", "2026");
fs.mkdirSync(outputDir, { recursive: true });  // Creates all needed folders
fs.writeFileSync(path.join(outputDir, "q1.txt"), "Q1 Report");

// --- Encoding is explicit in Node.js ---
// Always pass "utf-8" as the second argument to readFileSync
// Without it, you get a raw Buffer instead of a string:
let buffer = fs.readFileSync("data.txt");        // Buffer (raw bytes)
let text = fs.readFileSync("data.txt", "utf-8"); // String (decoded)

using System.IO;
using System.Text;

// --- Handle specific file errors ---
try
{
    string content = File.ReadAllText("missing_file.txt");
}
catch (FileNotFoundException)
{
    Console.WriteLine("Error: File not found. Check the path.");
}
catch (UnauthorizedAccessException)
{
    Console.WriteLine("Error: No permission to read this file.");
}
catch (DirectoryNotFoundException)
{
    Console.WriteLine("Error: The directory doesn't exist.");
}
catch (IOException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

// --- Check before opening ---
string filePath = "data/config.txt";

if (!File.Exists(filePath))
{
    Console.WriteLine($"File not found: {filePath}");
}
else
{
    string content = File.ReadAllText(filePath);
    Console.WriteLine($"Read {content.Length} characters.");
}

// --- Create directories if they don't exist ---
string outputDir = Path.Combine("output", "reports", "2026");
Directory.CreateDirectory(outputDir);  // Creates all needed folders
File.WriteAllText(Path.Combine(outputDir, "q1.txt"), "Q1 Report");

// --- Specifying encoding ---
// C# defaults to UTF-8 for File.ReadAllText, but be explicit:
string utf8Content = File.ReadAllText("data.txt", Encoding.UTF8);

// Writing with encoding:
File.WriteAllText("output.txt", "Héllo Wörld! 你好世界", Encoding.UTF8);