What this class was really about

On the surface, a Python refresher. Underneath, the instructor was disassembling an AI agent into its plain-Python parts, so that when LangChain/LangGraph arrive in a few weeks, “nothing feels like magic.”

Where this sits in the course

The instructor teaches from first principles — concepts before frameworks. This is Phase 0, deliberately placed before agents.

A Linux-style terminal on Windows

Several students hit errors on Windows. The instructor booted a fresh Windows install running as a VM on top of their Mac to reproduce the exact problem live — and used that VM to teach the “environment / container” idea in passing.

The container / environment intuition

Windows ran as a container on an environment inside macOS. Nothing on the Mac was available inside it — it started blank. The recurring question that motivates reproducible environments: if I set up the exact versions here and hand them to you, won't it just work on your machine too?

Three ways to type commands on Windows

The fix, step by step

1. Install VS Code and Git for Windows (Git Bash). During Git's installer, accept “add a Git Bash profile to Windows Terminal” and enable Git from the command line.
2. Latest Windows 11 already ships Windows Terminal — you don't install it. Confirm your build with winver.
3. Open Git Bash; now the standard install commands work.
4. In VS Code, open the terminal and pick the Git Bash profile — never PowerShell. “95% of what I do is in the terminal.”

winver                                            # check Windows build/version
curl -LsSf https://astral.sh/uv/install.sh | sh   # install uv — GIT BASH, not CMD/PowerShell
uv --version

uv python install                 # let uv manage a Python interpreter
uv init my_first_project          # scaffold main.py, pyproject.toml, .python-version
cd my_first_project
uv add requests                   # add a dependency (+ writes uv.lock)
uv pip install -r requirements.txt
source .venv/Scripts/activate     # activate venv (Windows / Git Bash)
# source .venv/bin/activate       # activate venv (macOS / Linux)
uv run main.py                    # run a file inside the managed env

Python & JSON refresher

A fast pass over the primitives, run in a notebook so outputs are visible. “I'm not teaching, I'm refreshing” — but the parts that bite people later were flagged deliberately.

Variables, types & f-strings

city = "Tokyo"
temperature = 21.5
is_raining = False

print(type(city))         # <class 'str'>
print(type(temperature))  # <class 'float'>
print(type(is_raining))   # <class 'bool'>
print(f"It is {temperature}°C in {city}.")   # f-string interpolation

Lists & negative indexing

cities = ["Tokyo", "Paris", "London"]
cities.append("Berlin")
print(cities[0])    # Tokyo  (first)
print(cities[-1])   # Berlin (last)
mixed = [1, "two", 3.0, True]   # a list can hold mixed types — no error

JSON is a dictionary (for this course)

JSON is how information travels between services, and it's just key–value pairs. Values can themselves be lists or nested dicts.

person = {
    "name": "Alice",          # key : value
    "age": 25,
    "skills": ["Python", "AI", "SQL"],  # a LIST of values
    "address": {"city": "Mumbai", "pin": "400001"}  # a nested dict / JSON
}

Reading values safely: .get() vs []

Real APIs return JSON, and the key you want may be missing. Demoed against the free Cat Facts API (returns {"fact": …, "length": …}).

reading = {"city": "Tokyo", "temp": 21.5}
print(reading["humidity"])       # 💥 KeyError — crashes
print(reading.get("humidity"))    # None — safe, no crash

for key, value in reading.items():
    print(key, "->", value)

Classes & OOP

Why learn OOP if AI writes the code? Because you must read what it produces — and every library, and the agent you'll build, is “just classes.” Visualised live in Python Tutor.

You wouldn't create a hundred accounts as bank_account_1 = 123, bank_account_2 = 234… Instead you define one blueprint (the class) and stamp out as many objects as you like.

class BankAccount:
    def __init__(self, owner: str, balance: float = 0):
        self.owner = owner          # set up THIS object's state
        self.balance = balance      # default 0 unless passed
        self.history = []

    def deposit(self, amount):
        self.balance += amount
        self.history.append(f"Deposited {amount}")

    def withdraw(self, amount):
        if amount > self.balance:        # guardrail: can't overdraw
            print("Insufficient funds"); return
        self.balance -= amount
        self.history.append(f"Withdrew {amount}")

    def show_history(self):
        for entry in self.history:
            print(entry)

acc1 = BankAccount("Mayank", 1000)
acc1.deposit(200)     # balance → 1200
acc1.withdraw(50)     # balance → 1150

Data classes

A @dataclass writes the boilerplate — __init__, __repr__, __eq__ — straight from type-hinted attributes. The Java-crowd shorthand: “it's like Lombok.”

from dataclasses import dataclass, field

@dataclass
class Book:
    title: str
    author: str
    pages_read: int = 0
    tags: list = field(default_factory=list)   # see the bug below

    def read(self, pages):
        self.pages_read += pages

    def add_tag(self, tag):
        self.tags.append(tag)

my_book = Book("Atomic Habits", "James Clear")
# No __init__ written by hand — the decorator generated it.

The line that confuses everyone: field(default_factory=list)

Why not just tags = []? Because a bare [] default is created once and secretly shared by every Book. Add a tag to one, it appears on all.

Error handling

When AI writes code, the first version usually throws errors. And when your code hits an API or an AI, the call will sometimes fail. The question posed: should your whole agent die because one call failed? No — so you wrap the risky bit.

def safe_divide(a, b):
    try:
        result = a / b                 # the risky line
    except ZeroDivisionError:
        print("Can't divide by zero — using 0 instead")
        result = 0
    finally:
        print("Done attempting the division")   # ALWAYS runs
    return result

Decorators

The analogy ran all session: you hand me a gift; I wrap it; the contents don't change, but what you get back is more than the plain box.

import functools

def announce(func):                 # takes a function…
    @functools.wraps(func)          # keep func's real __name__, __doc__
    def wrapper(*args, **kwargs):
        print(f"Starting {func.__name__}...")
        result = func(*args, **kwargs)   # run the original
        print(f"Finished {func.__name__}.")
        return result
    return wrapper                    # …returns an enhanced function

@announce
def greet(name):
    return f"Hello {name}"

print(greet("ma'am"))

The use case that makes it click: timing

import time, functools

def timed(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.time() - start:.4f}s")
        return result
    return wrapper

@timed
def slow_addition(a, b):
    time.sleep(1); return a + b

Calling an API — and the “fake AI”

The big de-mystification: talking to ChatGPT/Claude is the same shape as calling any web API. Send a request in the format the service wants; get JSON back. A fake AI was built in between so the leap from “API” to “AI” feels small.

A real API with requests

Using the free Frankfurter currency API (real ECB rates). The response comes back as JSON — which you already know is a dict.

import requests

def convert_currency(amount, from_ccy, to_ccy):
    url = f"https://api.frankfurter.app/latest?from={from_ccy}&to={to_ccy}"
    try:                                # this can fail → wrap it
        response = requests.get(url)
        data = response.json()          # APIs return JSON → a dict
        return amount * data["rates"][to_ccy]
    except Exception as e:
        print("API call failed:", e); return None

The “fake AI”: playing the role of ChatGPT

Rather than jump straight to a paid AI call, the instructor faked one — a function that plays the role of AI, taking the same model, max_tokens, messages inputs and returning a message.

def fake_ai(model, max_tokens, messages):
    user_message = messages[-1]["content"].lower()
    if "currency" in user_message or "convert" in user_message:
        reply = "I'd use a currency-conversion tool instead of guessing."
    elif "weather" in user_message:
        reply = "I'd use the weather tool."
    else:
        reply = "Ask me about currency or weather."
    return {"role": "assistant", "content": reply}   # a dict/JSON

for q in ["Convert $50 to Euro"]:
    response = fake_ai("gpt-x", 100, [{"role": "user", "content": q}])
    print(response["content"])

Pydantic

Python is dynamically typed — it will happily let a name be a number and an age be a string. Fine for a script, dangerous when data flows into a database, an API, or an agent.

The problem: type hints don't enforce anything

def create_user(name: str, age: int):
    return {"name": name, "age": age}

create_user("Mayank", "fifteen")   # runs fine — Python does NOT enforce the hint!

You could hand-write isinstance(...) checks — but you'd repeat them in create_user, update_user, delete_user… That doesn't scale.

The fix: a BaseModel

from pydantic import BaseModel

class User(BaseModel):     # inherit BaseModel — no __init__ needed
    name: str
    age: int

u1 = User(name="Mayank", age=25)     # ✓ correct types
u2 = User(name="Mayank", age="25")   # ✓ Pydantic COERCES "25" → 25
u3 = User(name="Mayank", age=-5)     # ✓ -5 IS a valid int (see note!)
u4 = User(name="Rahul", age=[1,2,3])  # ✗ ValidationError: not an int

Curated Q&A

From a long live Q&A, kept only where the answer teaches something reusable. Reveal each answer when you want it.

Reusable advice from the room

• Simple designs scale. Reach for a plain API call + orchestration before an agent — more control, fewer tokens, still scales.
• Read the code AI writes. “When it breaks, you're just sitting with AI.” The paid skill is going inside to see why it failed — which is why classes, decorators and types are non-negotiable.
• AI is ~15–20% of a project. The other 80% is ordinary software and data work. The same problem can need embeddings or not, depending on data + domain knowledge.
• Frontier models are usually the pragmatic client choice — battle-tested; self-hosting open models often costs more in infra/testing than it saves.
• Better instructions > new sessions. AI is fuzzy and tools carry hidden context. Improve prompt specificity rather than blaming randomness.
• uv is mature (~1.5 years); using it and a clean venv is what you say in an interview to show you can accelerate real development.
• Interview lens. Transformer/DSA depth is asked to prove you can handle hard problems, even if daily work is mostly integration.

Corrections worth pinning up

Small exercises from this session

Learning exercises derived from what was taught (not transcript content). Run each in a notebook or with uv run; reveal a hint only after attempting.

Check yourself

Answer in your head (or explain aloud), then reveal.

The whole session, compact

Session in 60 seconds

Get a Linux-style terminal (Git Bash) and uv so setups are reproducible. Refresh the primitives an agent is secretly built from: lists/dicts/JSON (APIs return JSON = dicts; use .get()), classes (blueprint + state), @dataclass (skip boilerplate; beware shared [] defaults), try/except/finally (wrap fragile calls), decorators (function → enhanced function; power agent tools), and API/AI calls (same request/response shape). Finish with Pydantic: dynamic typing is unsafe, so BaseModel enforces types (and, next class, data rules).

Core ideas

• An agent = class + state + functions + API calls + error handling + Pydantic validation. Nothing exotic.
• APIs (and AI) return JSON → fluency with dicts is the reusable skill.
• Type hints don't enforce; Pydantic does (coerces where it can, errors where it can't).
• Decorators wrap behaviour around an unchanged function — the mechanism behind agent tools.

Code patterns

data.get("k")                         # safe dict read → None if missing
tags: list = field(default_factory=list)  # dataclass mutable default (never = [])
try: risky()
except Exception as e: recover(e)
finally: cleanup()                    # always runs (close DB)
@functools.wraps(func)                # inside a decorator's wrapper
data = requests.get(url).json()      # → dict
class User(BaseModel): name: str; age: int   # typed, validated

Instructor takeaways

Recall prompts

Cover the notes and answer: Why Git Bash over PowerShell? · What does field(default_factory=list) prevent? · One sentence: what is a decorator? · Why does User(age="25") succeed but User(age=[1,2,3]) fail? · What's the difference between type and data validation?