Python + Tools

import psycopg                                   # pip install "psycopg[binary]"

with psycopg.connect("postgresql://app:secret@localhost:5432/shop") as con:
    with con.cursor() as cur:
        cur.execute(
            "SELECT customer, SUM(total) FROM orders WHERE status = %s GROUP BY customer",
            ("paid",),
        )
        for customer, spent in cur.fetchall():
            print(customer, spent)
    # leaving the block commits; an exception rolls back

import pandas as pd                                    # pip install pandas

orders = pd.read_csv("orders.csv", parse_dates=["created"])
customers = pd.read_json("customers.json")

# look
print(orders.head()); print(orders.dtypes); print(orders.describe())

# clean
orders = orders.dropna(subset=["total"])
orders["total"] = orders["total"].astype(float)
orders = orders[orders["status"] == "paid"]           # filter = boolean mask

# derive
orders["month"] = orders["created"].dt.to_period("M")

# group (the Module 03 counting loop, in one line)
by_customer = orders.groupby("customer")["total"].agg(["sum", "count"]).sort_values("sum", ascending=False)

# join
report = by_customer.merge(customers, left_index=True, right_on="name", how="left")

# out
report.to_csv("report.csv", index=False)
print(report.head(10))

from fastapi import FastAPI, HTTPException          # pip install fastapi uvicorn
from pydantic import BaseModel, Field

app = FastAPI(title="Orders API")

class OrderIn(BaseModel):
    customer: str = Field(min_length=1)
    total: float = Field(gt=0)

class Order(OrderIn):
    id: int

DB: dict[int, Order] = {}

@app.post("/orders", response_model=Order, status_code=201)
def create_order(body: OrderIn) -> Order:
    order = Order(id=len(DB) + 1, **body.model_dump())
    DB[order.id] = order
    return order

@app.get("/orders/{order_id}", response_model=Order)
def get_order(order_id: int) -> Order:
    if order_id not in DB:
        raise HTTPException(404, "no such order")
    return DB[order_id]

# $ uvicorn main:app --reload
# $ curl -X POST localhost:8000/orders -H "content-type: application/json" -d '{"customer":"ada","total":12.5}'
# {"customer":"ada","total":12.5,"id":1}

import time
import requests                                          # pip install requests

session = requests.Session()                             # reuses the connection; set auth once
session.headers["Authorization"] = "Bearer " + "YOUR_TOKEN"

def get_json(url, params=None, tries=3):
    for attempt in range(1, tries + 1):
        try:
            r = session.get(url, params=params, timeout=10)
            if r.status_code == 429 or r.status_code >= 500:       # rate-limited or server error: retry
                raise requests.HTTPError(f"{r.status_code} from {url}")
            r.raise_for_status()                                    # 4xx → exception with the reason
            return r.json()
        except (requests.ConnectionError, requests.Timeout, requests.HTTPError) as e:
            if attempt == tries:
                raise
            time.sleep(2 ** attempt)                                # 2, 4, 8 seconds

def all_pages(url):
    page = 1
    while True:
        data = get_json(url, params={"page": page, "per_page": 100})
        yield from data["items"]
        if not data.get("has_more"):
            break
        page += 1

for item in all_pages("https://api.example.com/orders"):
    print(item["id"])

# Dockerfile
FROM python:3.13-slim

WORKDIR /app
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1

# dependencies first — this layer is cached until requirements.txt changes
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# then the code
COPY . .
RUN useradd -m app && chown -R app /app
USER app

EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

# $ docker build -t orders-api .
# $ docker run -p 8000:8000 --env-file .env orders-api

import json
import boto3                                              # pip install boto3

s3 = boto3.client("s3")

s3.upload_file("report.csv", "my-bucket", "reports/2026-09/report.csv")
s3.download_file("my-bucket", "raw/orders.json", "orders.json")

obj = s3.get_object(Bucket="my-bucket", Key="raw/orders.json")
orders = json.loads(obj["Body"].read())                   # read straight into memory

for page in s3.get_paginator("list_objects_v2").paginate(Bucket="my-bucket", Prefix="raw/"):
    for o in page.get("Contents", []):
        print(o["Key"], o["Size"])

# lambda_function.py — AWS calls this with the triggering event
def handler(event, context):
    for record in event["Records"]:                       # e.g. an S3 "object created" event
        bucket = record["s3"]["bucket"]["name"]
        key = record["s3"]["object"]["key"]
        print(f"new file: s3://{bucket}/{key}")
    return {"statusCode": 200}

from pyspark.sql import SparkSession, functions as F   # pip install pyspark

spark = SparkSession.builder.appName("orders").getOrCreate()

orders = spark.read.parquet("s3://my-bucket/orders/")      # billions of rows is fine
customers = spark.read.json("s3://my-bucket/customers/")

report = (
    orders
    .filter(F.col("status") == "paid")
    .withColumn("month", F.date_trunc("month", "created"))
    .groupBy("customer", "month")
    .agg(F.sum("total").alias("spent"), F.count("*").alias("orders"))
    .join(customers, on="customer", how="left")
)

report.explain()                                           # the physical plan — nothing has run yet
report.write.mode("overwrite").partitionBy("month").parquet("s3://my-bucket/reports/")   # the action

from datetime import datetime, timedelta
from airflow.decorators import dag, task                 # pip install apache-airflow

@dag(schedule="0 6 * * *", start_date=datetime(2026, 1, 1), catchup=False,
     default_args={"retries": 2, "retry_delay": timedelta(minutes=5)})
def daily_orders():

    @task
    def extract() -> str:
        path = "/tmp/orders_raw.json"
        # ... call the API from the requests lesson, write the file
        return path

    @task
    def transform(path: str) -> str:
        # ... pandas: clean, group, write /tmp/report.csv
        return "/tmp/report.csv"

    @task
    def load(report: str) -> None:
        # ... boto3: upload to S3, or psycopg: insert into Postgres
        ...

    load(transform(extract()))      # the dependency graph: extract >> transform >> load

daily_orders()

# .gitignore — the Python essentials
.venv/
__pycache__/
*.pyc
.env                 # secrets — NEVER commit
.pytest_cache/
.mypy_cache/
*.egg-info/
dist/ build/
.ipynb_checkpoints/
data/                # large or private inputs; keep a small sample/ instead

# the loop
$ git switch -c feature/order-report          # a branch per change
$ python -m pytest                            # green before you commit
$ git add -p                                  # review each hunk you stage
$ git commit -m "report: group paid orders by month

Refunded orders were counted as revenue; filter on status first."
$ git push -u origin feature/order-report     # then open a pull request