# Create a list of driver names
drivers = ["Alice", "Bob", "Carol"]

# Access by index (starts at 0)
print(drivers[0])    # "Alice"
print(drivers[-1])   # "Carol" (last item)

# Lists are mutable — you can change them
drivers.append("David")   # add to end
drivers[1] = "Ben"        # update item

print(len(drivers))   # 4

# One database row comes back as a tuple
row = (1, "Alice", 850.50, "completed")
#      ↑ trip_id  ↑ driver  ↑ fare     ↑ status

# Access by index — same as list
print(row[0])   # 1  (trip_id)
print(row[3])   # "completed"

# Tuples are immutable — this crashes:
# row[0] = 99  → TypeError: 'tuple' object does not support item assignment

# Unpack a tuple into named variables
trip_id, driver, fare, status = row
print(driver)   # "Alice"

# After: cur.execute("SELECT trip_id, driver_id, fare_amount, status FROM trips")
rows = cur.fetchall()

# rows is a list of tuples:
# [
#   (1,  3, 850.50,  "completed"),
#   (2,  1, 420.00,  "cancelled"),
#   (3,  3, 1200.00, "completed"),
#   ...  up to 1,000,000 rows
# ]

# Access the first row
first_row = rows[0]         # (1, 3, 850.50, "completed")
print(first_row[2])        # 850.50  (fare_amount)

# How many rows came back?
print(len(rows))            # 1000000

# rows is the list of tuples from fetchall()
rows = [
    (1, "Alice", 850.50,  "completed"),
    (2, "Bob",   420.00,  "cancelled"),
    (3, "Alice", 1200.00, "completed"),
]

for row in rows:
    trip_id, driver, fare, status = row  # unpack the tuple
    print(f"Trip {trip_id}: {driver} — NPR {fare}")

# Output:
# Trip 1: Alice — NPR 850.5
# Trip 2: Bob   — NPR 420.0
# Trip 3: Alice — NPR 1200.0

for row_num, row in enumerate(rows, start=1):
    trip_id, driver, fare, status = row
    print(f"Row {row_num}/{len(rows)}: {driver}")

# Output:
# Row 1/3: Alice
# Row 2/3: Bob
# Row 3/3: Alice

# Why this matters in a pipeline:
# "Batch failed at row 2847/5000" is a useful error message.
# "Batch failed" tells you nothing.

trip_id, driver, fare, status = (1, "Alice", 850.50, "completed")

if status == "completed":
    print(f"Write to report: {driver} — NPR {fare}")
elif status == "cancelled":
    print(f"Skip: {driver} cancelled")
else:
    print(f"In progress — ignore for now")

# Flag high-value completed trips
if status == "completed" and fare > 1000:
    print(f"High-value trip: NPR {fare}")

# Skip if missing fare OR missing status
if fare is None or status is None:
    print("Incomplete row — skipping")
    continue   # jump to next loop iteration

# Check if status is one of several values
if status in ("completed", "in_progress"):
    valid_rows.append(row)

try:
    # Code that might fail goes here
    result = risky_operation()

except ValueError as e:
    # Runs only if a ValueError was raised
    print(f"Value error: {e}")

except Exception as e:
    # Catches ANY other exception
    print(f"Unexpected error: {e}")

else:
    # Runs ONLY if try completed with no exception
    # Perfect place for conn.commit()
    print("Success")

finally:
    # Always runs — even if an exception occurred
    # Perfect place for conn.close() or file.close()
    cleanup()

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s  %(levelname)s  %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
    handlers=[
        logging.FileHandler("pipeline.log"),    # write to file
        logging.StreamHandler()                    # also print to terminal
    ]
)
logger = logging.getLogger(__name__)

import csv

output_path = "completed_trips.csv"

with open(output_path, "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)

    # Write the header row first
    writer.writerow(["trip_id", "driver_id", "fare_amount", "status"])

    # Write each data row
    for row in completed_rows:
        writer.writerow(row)

# File is automatically closed here — even if an exception happened
logger.info(f"Wrote {len(completed_rows):,} rows to {output_path}")

"""
fetch_and_export.py
────────────────────
Connects to PostgreSQL, fetches completed trips,
writes them to a CSV file. Logs every step.
"""

import csv
import logging
import psycopg2

# ── 1. Logging setup ─────────────────────────────────────────────
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s  %(levelname)s  %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
    handlers=[
        logging.FileHandler("pipeline.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# ── 2. Database config ───────────────────────────────────────────
DB_CONFIG = dict(
    host="localhost", port=5432,
    dbname="ridedb", user="postgres", password="postgres"
)

QUERY = """
    SELECT trip_id, driver_id, rider_id,
           fare_amount, distance_km, status, requested_at
    FROM trips
    ORDER BY requested_at
"""

OUTPUT_FILE = "completed_trips.csv"
HEADERS = ["trip_id", "driver_id", "rider_id",
           "fare_amount", "distance_km", "status", "requested_at"]


# ── 3. Main function ─────────────────────────────────────────────
def fetch_and_export():

    # ── Connect ──────────────────────────────────────────────────
    logger.info("Connecting to database…")
    try:
        conn = psycopg2.connect(**DB_CONFIG)          # ** unpacks the dict
    except psycopg2.OperationalError as e:
        logger.critical(f"Cannot connect: {e}")
        raise                                         # stop — nothing to do

    # ── Fetch all rows ───────────────────────────────────────────
    logger.info("Running query…")
    try:
        with conn.cursor() as cur:                    # cursor auto-closes
            cur.execute(QUERY)
            all_rows = cur.fetchall()                  # list of tuples
    except Exception as e:
        logger.error(f"Query failed: {e}")
        conn.close()
        raise

    logger.info(f"Fetched {len(all_rows):,} rows total")

    # ── Filter and collect ───────────────────────────────────────
    completed_rows = []      # list to collect completed trips
    skipped = 0

    for row_num, row in enumerate(all_rows, start=1):  # loop + enumerate

        trip_id, driver_id, rider_id, fare, dist, status, req_at = row

        # Condition 1: only keep completed trips
        if status != "completed":
            skipped += 1
            continue

        # Condition 2: skip rows with null fare
        if fare is None:
            logger.warning(f"Row {row_num}: null fare — skipping")
            skipped += 1
            continue

        completed_rows.append(row)   # add to list

    logger.info(
        f"{len(completed_rows):,} completed rows | {skipped:,} skipped"
    )

    # ── Write to CSV ─────────────────────────────────────────────
    logger.info(f"Writing to {OUTPUT_FILE}…")
    try:
        with open(OUTPUT_FILE, "w", newline="", encoding="utf-8") as f:
            writer = csv.writer(f)
            writer.writerow(HEADERS)           # header row first
            for row in completed_rows:
                writer.writerow(row)           # each data row (tuple)
    except IOError as e:
        logger.error(f"Could not write file: {e}")
        raise

    logger.info(f"Done. {len(completed_rows):,} rows written to {OUTPUT_FILE}")
    conn.close()


# ── 4. Entry point ───────────────────────────────────────────────
if __name__ == "__main__":
    fetch_and_export()