This week, we build a Workout Tracker Suite that helps you log lifts, visualize progress, and optimize your training — perfect for anyone serious about strength training!

• Day 1: Barbell Plate Calculator (Tkinter GUI)

• Day 2: Workout Logger with Live Charts

• Day 3: Complete Workout Dashboard (Today)

View All Projects This Week

Today’s Project

Welcome to the finale! We’ve built a plate calculator and workout logger. Today we’re creating a complete training dashboard with templates, 1RM calculator, strength standards, and session timers!

You’ll have a professional-grade workout tracking system that rivals commercial fitness apps!

Project Task

Create a complete workout dashboard with:

• Workout templates (Push/Pull/Legs, Upper/Lower, Full Body)

• 1RM (one-rep max) calculator with multiple formulas

• Strength standards comparison (beginner/intermediate/advanced)

• Session timer with rest period alerts

• Progressive overload recommendations

• Volume tracking with periodization suggestions

• Export workout reports as text files

• Enhanced charts with volume and intensity trends

• All Day 1 & 2 features integrated

This project gives you hands-on practice with advanced GUI design, mathematical formulas, timer functionality, template systems, data analysis, and building production-ready fitness applications — essential skills for complete software solutions!

Expected Output

We have gone one step further in this version of the GUI and added tabs. This is a major milestone because it demonstrates one of the most popular techniques to organize a GUI when we are adding more features in the app. With tabs we can organize the various functionalities of the apps as you can see below:

For example, we have now moved the weight progress to a new “Analytics” tab:

And we have also added other tabs as it can be seen in the screenshots.

Setup Instructions

Install Required Packages:

pip install matplotlib pandas

Run the dashboard:

python workout_dashboard.py

All features ready to use:

• No additional setup needed

• Data persists in CSV files

• Templates saved as JSON

• Reports export as TXT files

Understanding 1RM Calculations

What is 1RM?

Your one-rep max - the maximum weight you can lift for exactly one rep.

Why calculate it?

• Design training programs (% of 1RM)

• Track true strength gains

• Compare against standards

• Set realistic goals

Common formulas:

1. Epley Formula:

1RM = weight × (1 + reps/30)

# Example: 225 lbs × 8 reps
1RM = 225 × (1 + 8/30)
1RM = 225 × 1.267
1RM = 285 lbs

2. Brzycki Formula:

1RM = weight × (36 / (37 - reps))

# Example: 225 lbs × 8 reps
1RM = 225 × (36 / (37 - 8))
1RM = 225 × (36 / 29)
1RM = 279 lbs

3. Lander Formula:

1RM = (100 × weight) / (101.3 - 2.67123 × reps)

# Example: 225 lbs × 8 reps
1RM = (100 × 225) / (101.3 - 2.67123 × 8)
1RM = 22500 / 79.93
1RM = 281 lbs

Our implementation:

def calculate_1rm(weight, reps):
    # Epley
    epley = weight * (1 + reps/30)
    
    # Brzycki
    brzycki = weight * (36 / (37 - reps))
    
    # Lander
    lander = (100 * weight) / (101.3 - 2.67123 * reps)
    
    # Lombardi
    lombardi = weight * (reps ** 0.10)
    
    # Average
    average = (epley + brzycki + lander + lombardi) / 4
    
    return {
        'epley': round(epley, 1),
        'brzycki': round(brzycki, 1),
        'lander': round(lander, 1),
        'lombardi': round(lombardi, 1),
        'average': round(average, 1)
    }

Understanding Strength Standards

What are strength standards?

Benchmarks for comparing your lifts to typical progression levels.

Standard categories:

STRENGTH_STANDARDS = {
    'Bench Press': {
        'Beginner': 0.75,      # 0.75× bodyweight
        'Novice': 1.0,         # 1.0× bodyweight
        'Intermediate': 1.25,  # 1.25× bodyweight
        'Advanced': 1.5,       # 1.5× bodyweight
        'Elite': 1.75,         # 1.75× bodyweight
    },
    'Squat': {
        'Beginner': 1.0,
        'Novice': 1.5,
        'Intermediate': 2.0,
        'Advanced': 2.5,
        'Elite': 3.0,
    },
    'Deadlift': {
        'Beginner': 1.25,
        'Novice': 1.75,
        'Intermediate': 2.25,
        'Advanced': 2.75,
        'Elite': 3.25,
    }
}

Understanding Workout Templates

What are templates?

Pre-designed workout programs with exercises, sets, reps, and rest times.

Common splits:

Push/Pull/Legs (PPL):

TEMPLATES = {
    'Push': [
        {'exercise': 'Bench Press', 'sets': 4, 'reps': 8, 'rest': 180},
        {'exercise': 'Overhead Press', 'sets': 3, 'reps': 10, 'rest': 120},
        {'exercise': 'Incline DB Press', 'sets': 3, 'reps': 12, 'rest': 90},
        {'exercise': 'Lateral Raises', 'sets': 3, 'reps': 15, 'rest': 60},
        {'exercise': 'Tricep Extensions', 'sets': 3, 'reps': 12, 'rest': 60},
    ],
    'Pull': [
        {'exercise': 'Deadlift', 'sets': 3, 'reps': 5, 'rest': 180},
        {'exercise': 'Pull-ups', 'sets': 3, 'reps': 10, 'rest': 120},
        {'exercise': 'Barbell Row', 'sets': 4, 'reps': 8, 'rest': 120},
        {'exercise': 'Face Pulls', 'sets': 3, 'reps': 15, 'rest': 60},
        {'exercise': 'Bicep Curls', 'sets': 3, 'reps': 12, 'rest': 60},
    ],
    'Legs': [
        {'exercise': 'Squat', 'sets': 4, 'reps': 6, 'rest': 180},
        {'exercise': 'Romanian Deadlift', 'sets': 3, 'reps': 10, 'rest': 120},
        {'exercise': 'Leg Press', 'sets': 3, 'reps': 12, 'rest': 90},
        {'exercise': 'Leg Curls', 'sets': 3, 'reps': 15, 'rest': 60},
        {'exercise': 'Calf Raises', 'sets': 4, 'reps': 20, 'rest': 60},
    ]
}

Loading a template:

def load_template(template_name):
    exercises = TEMPLATES[template_name]
    
    print(f"\n{template_name.upper()} DAY:")
    for i, ex in enumerate(exercises, 1):
        print(f"{i}. {ex['exercise']}")
        print(f"   {ex['sets']}×{ex['reps']}")
        print(f"   Rest: {ex['rest']}s")

We also have other features such as the timer which the user can use to time your workout sessions.

What You’ve Accomplished This Week

🎉 Congratulations! You’ve built a complete workout tracking system!

• Day 1: Visual plate calculator

• Day 2: Workout logger with charts

• Day 3: Complete training dashboard

You now have:

✅ Plate calculator - Visual barbell loading
✅ Workout logging - Track all exercises
✅ Progress charts - See gains visualized
✅ 1RM calculator - Multiple formulas
✅ Strength standards - Compare your lifts
✅ Workout templates - Pre-built programs
✅ Session timers - Track workout & rest
✅ Analytics - Volume & intensity trends
✅ Export reports - Share your progress
✅ Professional GUI - Tabbed interface

Next steps:

• Add exercise video library

• Integrate with fitness trackers

• Build mobile version

• Add nutrition tracking

• Social features (share workouts)

• Online coaching integration

You’ve built the foundation for a complete fitness platform! 🚀

View Code Evolution

Compare today’s complete dashboard with earlier versions and see the full progression from simple calculator → logger → complete system!

Read more

This week, we build a Workout Tracker Suite that helps you log lifts, visualize progress, and optimize your training — perfect for anyone serious about strength training!

• Day 1: Barbell Plate Calculator (Tkinter GUI)

• Day 2: Workout Logger with Live Charts (Today)

• Day 3: Complete Workout Dashboard

View All Projects This Week

Today’s Project

Yesterday we built a plate calculator. Today we’re adding workout logging with live progress charts! Log your sets, track your PRs, and see your strength gains visualized in real-time!

You’ll enhance the app into a complete training tracker with embedded matplotlib charts!

Project Task

Enhance the plate calculator with workout logging:

• Log exercises with sets, reps, weight, and RPE

• Save workouts to CSV with timestamps

• Live progress chart showing weight over time

• Personal records (PR) tracker

• Exercise history viewer

• Volume calculations (sets × reps × weight)

• Filter by exercise and date range

• Embedded matplotlib charts in Tkinter

• All Day 1 features still work

This project gives you hands-on practice with CSV data storage, pandas data analysis, matplotlib integration in Tkinter, data visualization, progressive overload tracking, and building data-driven fitness tools — essential skills for analytics applications!

Expected Output

Running the enhanced workout logger:

python workout_logger.py

Log a workout:

In this version the user can log in a workout such as bench press, squat, etc. These can be chosen from the drop down list:

After some days, you will see a weight progress at the bottom part of the GUI showing how your weights have changed over time:

CSV file generated:

Every time you log in a workout, the data are saved in a local workouts.csv file. For the example demonstrated above, here is how the file looks like:

date,time,exercise,sets,reps,weight,rpe,volume
2026-05-13,14:30:00,Bench Press,3,8,225,8,5400
2026-05-13,14:45:00,Squat,4,6,315,9,7560
2026-05-13,15:00:00,Deadlift,3,5,405,9,6075
2026-05-10,15:15:00,Bench Press,4,6,215,7,5160
2026-05-10,15:30:00,Squat,3,8,295,8,7080

Setup Instructions

Install Required Package:

pip install matplotlib pandas

Run the logger:

python workout_logger.py

Data storage:

• Workouts saved to workouts.csv automatically

• PRs tracked automatically

• Charts update in real-time

Understanding CSV Workout Storage

Why CSV for workouts?

Read more

This week, we build a Workout Tracker Suite that helps you log lifts, visualize progress, and optimize your training — perfect for anyone serious about strength training!

Why build this? Because tracking workouts manually is tedious, and most apps are overcomplicated. You’ll create tools that solve real problems: calculating plates, logging progress, and seeing gains visualized!

What you’ll learn: This series teaches you GUI development, data visualization, mathematical calculations, user interface design, and building practical fitness tools — essential skills for desktop applications!

Why users love this: A plate calculator that shows exactly what your barbell looks like? Instant dopamine! By Day 3, you’ll have a complete training dashboard that tracks every lift and shows your progress charts in real-time!

• Day 1: Barbell Plate Calculator (Tkinter GUI) (Today)

• Day 2: Workout Logger with Live Charts

• Day 3: Complete Workout Dashboard

View All Projects This Week

Today’s Project

We’re starting with something immediately satisfying: a visual plate calculator that shows you exactly how to load your barbell! No more mental math at the gym!

You’ll build a beautiful GUI that calculates the optimal plate combination and displays your loaded barbell visually!

Project Task

Create a barbell plate calculator with:

• Target weight input (kg or lbs)

• Visual barbell display showing loaded plates

• Optimal plate combination calculator

• Common lift presets (45/135, 60/185, 100/225, etc.)

• Support for standard plate sets (45, 35, 25, 10, 5, 2.5)

• Bar weight selection (20kg/45lbs standard, women’s bar, specialty bars)

• Save favorite lifts

• Clean, intuitive Tkinter interface

• Color-coded plates by weight

• Real-time updates as you type

This project gives you hands-on practice with Tkinter GUI, canvas drawing, mathematical optimization, event handling, and building visual tools — essential skills for desktop applications!

Expected Output

The app runs on the desktop. It lets the user to set the target weight. Based on that, the visual is instantly updated with the correct number of plates and their weights for the target weight:

The user can also press the “Save Current” button to save a configuration and load it later.

Setup Instructions

No installations needed!

Uses Python standard library only (Tkinter is built-in):

python plate_calculator.py

Understanding Plate Calculation Algorithm

The Challenge:

Given a target weight, find the minimum number of plates to load on each side.

Standard plate sets:

Pounds (lbs):

• 45 lbs (red) - biggest

• 35 lbs (yellow)

• 25 lbs (green)

• 10 lbs (white)

• 5 lbs (blue)

• 2.5 lbs (small red)

Kilograms (kg):

• 25 kg (red)

• 20 kg (blue)

• 15 kg (yellow)

• 10 kg (green)

• 5 kg (white)

• 2.5 kg (small red)

• 1.25 kg (small blue)

Algorithm (Greedy approach):

def calculate_plates(target_weight, bar_weight, plates):
    # Weight needed on plates (both sides)
    plates_weight = target_weight - bar_weight
    
    # Weight per side
    weight_per_side = plates_weight / 2
    
    # Greedy algorithm: largest plates first
    plates_needed = []
    remaining = weight_per_side
    
    for plate in sorted(plates, reverse=True):
        count = int(remaining / plate)
        if count > 0:
            plates_needed.append((plate, count))
            remaining -= plate * count
    
    return plates_needed

# Example
target = 225  # lbs
bar = 45      # lbs
plates = [45, 35, 25, 10, 5, 2.5]

result = calculate_plates(target, bar, plates)
# [(45, 1), (25, 1), (10, 1), (5, 1)]
# = 1×45 + 1×25 + 1×10 + 1×5 = 85 lbs per side
# = 85 × 2 + 45 bar = 215 lbs... wait, that's not 225!

Problem: Rounding!

225 - 45 = 180 lbs plates / 2 = 90 lbs per side

But 1×45 + 1×25 + 1×10 + 1×5 = 85 lbs per side (10 lbs short!)

Solution: Round to nearest 5 lbs (smallest plate × 2)

def calculate_plates(target, bar, plates):
    # Round to nearest achievable weight
    smallest_increment = min(plates) * 2  # 2.5 × 2 = 5 lbs
    target = round(target / smallest_increment) * smallest_increment
    
    weight_per_side = (target - bar) / 2
    
    # ... rest of algorithm

Understanding Tkinter Canvas Drawing

Why Canvas?

Tkinter Canvas lets us draw custom graphics:

import tkinter as tk

root = tk.Tk()
canvas = tk.Canvas(root, width=800, height=200, bg='white')
canvas.pack()

# Draw rectangle (plate)
canvas.create_rectangle(100, 50, 150, 150, fill='red', outline='black')

# Draw circle
canvas.create_oval(300, 75, 350, 125, fill='blue')

# Draw line (barbell)
canvas.create_line(50, 100, 750, 100, fill='gray', width=10)

# Draw text
canvas.create_text(400, 50, text="225 lbs", font=('Arial', 16, 'bold'))

root.mainloop()

Our barbell drawing:

def draw_barbell(canvas, plates_per_side):
    canvas.delete('all')  # Clear previous
    
    # Bar dimensions
    bar_length = 600
    bar_x_start = 100
    bar_y = 100
    
    # Draw bar
    canvas.create_line(
        bar_x_start, bar_y,
        bar_x_start + bar_length, bar_y,
        fill='gray', width=15
    )
    
    # Draw plates on left side
    x_offset = bar_x_start - 10
    for plate_weight, count in plates_per_side:
        for _ in range(count):
            color = get_plate_color(plate_weight)
            width = get_plate_width(plate_weight)
            height = get_plate_height(plate_weight)
            
            # Draw plate
            canvas.create_rectangle(
                x_offset - width, bar_y - height/2,
                x_offset, bar_y + height/2,
                fill=color, outline='black', width=2
            )
            
            # Label
            canvas.create_text(
                x_offset - width/2, bar_y - height/2 - 15,
                text=str(plate_weight), font=('Arial', 10, 'bold')
            )
            
            x_offset -= width + 5
    
    # Mirror for right side
    # ...

Understanding Saved Lifts

Persistence with JSON:

import json
from pathlib import Path

SAVED_LIFTS_FILE = 'saved_lifts.json'

def save_lift(name, weight, unit):
    # Load existing
    if Path(SAVED_LIFTS_FILE).exists():
        with open(SAVED_LIFTS_FILE, 'r') as f:
            lifts = json.load(f)
    else:
        lifts = {}
    
    # Add new
    lifts[name] = {'weight': weight, 'unit': unit}
    
    # Save
    with open(SAVED_LIFTS_FILE, 'w') as f:
        json.dump(lifts, f, indent=2)

def load_lifts():
    if Path(SAVED_LIFTS_FILE).exists():
        with open(SAVED_LIFTS_FILE, 'r') as f:
            return json.load(f)
    return {}

# Usage
save_lift('Squat', 315, 'lbs')
save_lift('Bench', 225, 'lbs')

lifts = load_lifts()
# {'Squat': {'weight': 315, 'unit': 'lbs'}, ...}

Practical Use Cases

1. Pre-planning workouts:

Before gym: Check what plates you need
At gym: Load bar exactly right, no confusion

2. Progressive overload:

Current: 225 lbs
Next week: 230 lbs
Calculator: Shows you need 2.5 lb plates!

3. Home gym setup:

See which plates you use most
Buy optimal plate set
Avoid buying unnecessary weights

4. Teaching form:

Show beginners what "135" looks like
Visual reference for proper loading
Safety check before lifting

5. Multiple lifters:

Save each person's working weights
Quick load for different people
No mental math during workout

Coming Tomorrow

Tomorrow we’re adding workout logging with live progress charts! Log your sets/reps/weight and see your strength gains visualized in real-time. The plate calculator becomes part of a complete training tool!

Skeleton and Solution

Below you will find both a downloadable skeleton.py file to help you code the project with comment guides and the downloadable solution.py file containing the correct solution.

Get the code skeleton here:

View Code Skeleton

Get the code solution here:

View Code Solution

This week, we build an AI-Powered Daily Journal that writes markdown entries, analyzes your mood with AI, and visualizes your emotional patterns over time!

• Day 1: Markdown Journal Writer

• Day 2: AI Mood & Theme Analyzer

• Day 3: Insights Dashboard (Today)

View All Projects This Week

Today’s Project

Welcome to the finale! We’ve built a journal with AI analysis. Today we’re creating a beautiful Streamlit dashboard with mood charts, word clouds, and AI-generated monthly summaries!

You’ll visualize your emotional journey and discover patterns you never noticed!

Project Task

Create a Streamlit insights dashboard with:

• Mood-over-time line chart (interactive with Plotly)

• Word cloud from all journal entries

• Monthly summary cards (AI-generated)

• Theme frequency chart

• Entry statistics and streaks

• Filter by date range

• Export insights as PDF

• Beautiful, intuitive interface

This project gives you hands-on practice with Streamlit, data visualization, Plotly charts, word clouds, dashboard design, and building data-driven applications — essential skills for analytics and insight tools!

Expected Output

Running the dashboard:

streamlit run dashboard.py

Browser opens with dashboard showing your mood in a graph:

Scrolling down the webpage you will find the score for the average mood, a word cloud showing the most used words in your journal, and the top themes you have written about:

Setup Instructions

Install Required Packages:

pip install streamlit plotly wordcloud langchain-google-genai

Set Google API Key:

export GOOGLE_API_KEY="your-key-here"

Run the dashboard:

streamlit run dashboard.py

Browser automatically opens to

http://localhost:8501

Make sure you have some jornal entries in the same directory with the dashboard.py file. Here are some sample files you can use:

Download Data

Understanding Streamlit Layout

Dashboard structure:

Read more

This week, we build an AI-Powered Daily Journal that writes markdown entries, analyzes your mood with AI, and visualizes your emotional patterns over time!

• Day 1: Markdown Journal Writer

• Day 2: AI Mood & Theme Analyzer (Today)

• Day 3: Insights Dashboard

View All Projects This Week

Today’s Project

Yesterday we built a markdown journal. Today we’re adding AI-powered analysis — Gemini reads each entry, scores your mood from -1 (negative) to +1 (positive), and extracts 3-5 recurring themes!

All analysis is cached as JSON metadata, so re-running is instant and free!

Project Task

Enhance the journal with AI analysis that:

• New review command analyzes entries

• Uses Gemini to score mood (-1 to 1 scale)

• Extracts 3-5 recurring themes per entry

• Caches analysis as JSON metadata files

• Re-runs are instant (reads from cache)

• Shows mood trends over time

• Lists most common themes across all entries

• Clean output with mood emoji indicators

• All Day 1 features still work

This project gives you hands-on practice with AI analysis, sentiment analysis, theme extraction, JSON caching, metadata management, and building intelligent tools — essential skills for AI-powered applications!

Expected Output

Analyzing entries for the first time:

python journal.py review

Console Output:

Setup Instructions

Install Required Package:

pip install langchain-google-genai

Get Your Google API Key:

1. Go to Google AI Studio

2. Click “Create API Key”

3. Copy your key

4. Set environment variable:

# Mac/Linux
export GOOGLE_API_KEY="your-key-here"

# Windows (PowerShell)
$env:GOOGLE_API_KEY="your-key-here"

Or edit the script:

This is a simpler method to provide the API key, but less secure.

GOOGLE_API_KEY = "your-key-here"  # Paste your key

Run analysis:

python journal.py review

Understanding AI Mood Analysis

What is mood scoring?

The AI reads your entry and assigns a score from -1 to 1:

 1.0  Very positive   😄  Joyful, excited, grateful, accomplished
 0.5  Positive        🙂  Happy, content, optimistic
 0.0  Neutral         😐  Balanced, matter-of-fact
-0.5  Negative        😔  Sad, frustrated, disappointed
-1.0  Very negative   😢  Devastated, hopeless, extremely upset

How it works:

Read more

This week, we build an AI-Powered Daily Journal that writes markdown entries, analyzes your mood with AI, and visualizes your emotional patterns over time!

Why build this? Because journaling is powerful for mental clarity and self-reflection. You’ll create a tool that not only stores your thoughts but also uses AI to understand them and show you patterns you might miss!

What you’ll learn: This series teaches you file-based data storage, markdown formatting, CLI tool development, AI sentiment analysis, data visualization, and building applications that provide real insights — essential skills for personal productivity tools!

Why users love this: A journal that understands you! By Day 3, you’ll have mood charts, word clouds, and AI-generated summaries showing your emotional journey and recurring themes. It’s like having a therapist and data analyst in one!

• Day 1: Markdown Journal Writer (Today)

• Day 2: AI Mood & Theme Analyzer

• Day 3: Insights Dashboard

View All Projects This Week

Today’s Project

We’re starting with the foundation: a command-line journal that greets you with randomized reflection prompts, saves entries as dated markdown files, and lets you search through your past thoughts! We will not use AI today yet.

You’ll learn file-based storage, markdown formatting, and building a clean CLI for daily use!

Project Task

Create a markdown journal system that:

• Date-based entries (one file per day: YYYY-MM-DD.md)

• Stores entries in journal/ folder

• Randomized reflection prompts

• Commands: new, list, search, open

• Markdown formatting for entries

• Timestamp each entry

• Clean CLI interface with argparse

• Search through past entries

• Open entries in your editor

This project gives you hands-on practice with file organization, markdown formatting, command-line tools, argparse, pathlib, datetime handling, and building daily-use tools — essential skills for productivity applications!

Expected Output

Creating a new journal entry:

python journal.py new

Console Output:

Generated file: journal/2026-05-12.md

# Friday, April 26, 2026

## 📝 Entry 1 - 10:30 AM

**Prompt:** What's one small thing that brought you joy today?

Had a great coffee this morning at the new cafe downtown.
The barista remembered my order - made me feel like a regular.
Spent the afternoon coding a new project. Made real progress!
Feeling accomplished and energized.

---

Listing all entries:

python journal.py list

Output:

Searching entries:

python journal.py search "coffee"

Output:

Opening a specific entry:

python journal.py open 2026-04-26

Output:

Setup Instructions

No installations needed!

Uses Python standard library only:

python journal.py new

The journal creates:

• journal/ folder (auto-created on first use)

• One .md file per day (e.g., 2026-05-12.md)

• Each file contains all entries for that day

Understanding File-Based Journaling

Why file-based?

✅ Simple - Just markdown files, no database
✅ Portable - Copy your journal/ folder anywhere
✅ Human-readable - Open files in any text editor
✅ Git-friendly - Version control your thoughts
✅ Privacy - Files stay on your computer
✅ Future-proof - Markdown will always be readable

File structure:

your-project/
├── journal.py
└── journal/
    ├── 2026-04-26.md
    ├── 2026-04-25.md
    ├── 2026-04-24.md
    └── ...

Why YYYY-MM-DD format?

Putting the year before is usually better in programming and working with files:

2026-04-26.md  ✅ Sorts chronologically
26-04-2026.md  ❌ Sorts incorrectly
april-26.md    ❌ No year, doesn't sort

Understanding pathlib

Modern file handling with pathlib:

from pathlib import Path

# Create journal directory
journal_dir = Path("journal")
journal_dir.mkdir(exist_ok=True)  # Create if doesn't exist

# Build file path
date_str = "2026-04-26"
file_path = journal_dir / f"{date_str}.md"
# Result: journal/2026-04-26.md

# Check if file exists
if file_path.exists():
    print("Entry already exists!")

# Read file
content = file_path.read_text()

# Write file
file_path.write_text(content)

# List all journal files
entries = sorted(journal_dir.glob("*.md"))

Why pathlib over os.path?

# OLD way (os.path)
import os
path = os.path.join("journal", date_str + ".md")

# NEW way (pathlib)
from pathlib import Path
path = Path("journal") / f"{date_str}.md"

✅ Cleaner syntax - / operator joins paths
✅ Object-oriented - Methods like .exists(), .read_text()
✅ Cross-platform - Handles Windows/Mac/Linux differences

Understanding argparse for CLI

Building a professional CLI:

import argparse

parser = argparse.ArgumentParser(description="AI Daily Journal")

# Add subcommands
subparsers = parser.add_subparsers(dest='command')

# 'new' command
new_parser = subparsers.add_parser('new', help='Create new entry')

# 'list' command
list_parser = subparsers.add_parser('list', help='List all entries')
list_parser.add_argument('--all', action='store_true', help='Show all entries')

# 'search' command
search_parser = subparsers.add_parser('search', help='Search entries')
search_parser.add_argument('query', help='Search term')

# 'open' command
open_parser = subparsers.add_parser('open', help='Open entry')
open_parser.add_argument('date', help='Date (YYYY-MM-DD)')

# Parse arguments
args = parser.parse_args()

if args.command == 'new':
    create_entry()
elif args.command == 'list':
    list_entries(show_all=args.all)
elif args.command == 'search':
    search_entries(args.query)
elif args.command == 'open':
    open_entry(args.date)

Result:

python journal.py new              # Create entry
python journal.py list             # List recent
python journal.py list --all       # List all
python journal.py search "coffee"  # Search
python journal.py open 2026-04-26  # Open

Understanding Reflection Prompts

Why prompts?

Random prompts help you:

• Break through writer’s block

• Explore different aspects of your day

• Maintain variety in entries

• Discover new insights

Our prompt bank:

REFLECTION_PROMPTS = [
    "What's one small thing that brought you joy today?",
    "What challenged you today, and what did you learn from it?",
    "What are you grateful for right now?",
    "What's on your mind that you need to get out?",
    "What progress did you make today, no matter how small?",
    "What would you do differently if you could redo today?",
    "Who or what inspired you today?",
    "What's something you're looking forward to?",
    "What did you do today that aligned with your values?",
    "What's one thing you want to remember about today?"
]

Selecting a random prompt:

import random

prompt = random.choice(REFLECTION_PROMPTS)
print(f"💭 Reflection Prompt:\n\"{prompt}\"")

Understanding Markdown Formatting

Why markdown for journals?

✅ Readable - Plain text with simple formatting
✅ Portable - Works everywhere
✅ Structured - Headers, lists, emphasis
✅ Future-proof - Never becomes obsolete

Our entry structure:

# Friday, April 26, 2026          ← Day header

## 📝 Entry 1 - 10:30 AM          ← Entry header

**Prompt:** What brought you joy? ← Prompt (bold)

Entry text goes here...           ← User's writing
Multiple paragraphs supported.

---                               ← Separator

Markdown elements we use:

# H1 Header          → Day title
## H2 Header         → Entry number
**bold**            → Prompt label
---                 → Horizontal rule (separator)

Understanding Entry Metadata

What we track:

entry_data = {
    'date': '2026-04-26',
    'day_name': 'Friday',
    'entry_number': 1,
    'timestamp': '10:30 AM',
    'prompt': 'What brought you joy today?',
    'content': '...',
    'word_count': 32,
    'char_count': 189
}

Why track this:

• Know how many entries per day

• See when you journal (morning/evening patterns)

• Track writing volume over time

• Tomorrow: AI will analyze this data!

Practical Use Cases

1. Daily reflection:

# Every morning
python journal.py new
# Write about yesterday, plan for today

2. Gratitude practice:

# Focus on positive moments
python journal.py new
# Prompt guides you to find joy

3. Problem processing:

# When stressed or confused
python journal.py new
# Writing clarifies thoughts

4. Review patterns:

# Look back at your month
python journal.py list
# See frequency and themes

5. Find specific memories:

# Remember that conversation?
python journal.py search "conversation"
# Find when you wrote about it

Coming Tomorrow

Tomorrow we’re adding AI mood and theme analysis with Gemini! The AI will read each entry, score your mood from -1 (negative) to +1 (positive), and extract 3-5 recurring themes. All cached as JSON so re-runs are free!

Skeleton and Solution

Below you will find both a downloadable skeleton.py file to help you code the project with comment guides and the downloadable solution.py file containing the correct solution.

Get the code skeleton here:

View Skeleton

Get the code solution here:

View Code Solution

This week, we build a Desktop Notification System that displays toast notifications, schedules reminders, and manages alerts — perfect for building productivity tools!

• Day 1: Simple Desktop Notifications

• Day 2: Scheduled Notifications & Timers

• Day 3: Smart Notification Manager with Persistence (Today)

View All Projects This Week

Today’s Project

Welcome to the finale! We’ve built notifications and timers. Today we’re creating a complete notification management system with saved reminders, templates, and a persistent scheduler that remembers everything!

You’ll build a manager that saves your notifications, loads them on startup, and runs multiple scheduled reminders simultaneously!

Project Task

Create a complete notification management system with:

• Save notifications to JSON file

• Load saved notifications on startup

• Manage multiple scheduled notifications

• Create reusable notification templates

• List all active/scheduled notifications

• Cancel specific notifications

• Edit and update notifications

• Persistent storage between sessions

• Clean command-line interface

This project gives you hands-on practice with JSON persistence, data management, state tracking, CRUD operations, and building production-ready tools — essential skills for real-world applications!

Expected Output

Running the notification manager:

python solution.py

Console Output:

First you need to set up a scheduled notification in the terminal. Notice that we are also creating a template out of it.

Then, the notification will trigger as a native desktop notification:

Saved JSON file: notifications_data.json

{
  "notifications": [
    {
      "id": "notif_001",
      "title": "Team Meeting",
      "message": "Weekly sync starts now",
      "type": "scheduled",
      "time": "14:00",
      "status": "active",
      "created_at": "2026-04-26T10:15:00",
      "template_name": "Weekly Team Meeting"
    },
    {
      "id": "notif_002",
      "title": "Hydration Reminder",
      "message": "Time to drink water!",
      "type": "recurring",
      "interval_minutes": 60,
      "status": "active",
      "created_at": "2026-04-26T10:20:00",
      "template_name": "Hydration Reminder"
    }
  ],
  "templates": [
    {
      "name": "Daily Standup",
      "type": "scheduled",
      "time": "09:30",
      "title": "Daily Standup",
      "message": "Morning team sync",
      "use_count": 15
    },
    {
      "name": "Hydration Reminder",
      "type": "recurring",
      "interval_minutes": 60,
      "title": "Hydration Reminder",
      "message": "Time to drink water!",
      "use_count": 5
    }
  ]
}

Setup Instructions

No new installations needed!

Same setup as Days 1 & 2:

macOS:

python solution.py

Windows:

pip install win10toast  # If not already installed
python solution.py

Linux:

python solution.py

Data file:

• Creates notifications_data.json automatically

• Loads on startup

• Saves on exit or after changes

Understanding Data Persistence

Why persist data?

Without persistence:

• ❌ All notifications lost when program closes

• ❌ Must recreate reminders every time

• ❌ Can’t track notification history

With persistence:

• ✅ Notifications survive program restarts

• ✅ Templates saved for reuse

• ✅ History of completed notifications

• ✅ Resume where you left off

Our approach:

# On startup
def load():
    with open('notifications_data.json', 'r') as f:
        data = json.load(f)
    return data

# On exit or after changes
def save():
    with open('notifications_data.json', 'w') as f:
        json.dump(data, f, indent=2)

Understanding the Data Structure

notifications_data.json structure:

{
  "notifications": [
    {
      "id": "notif_001",           // Unique identifier
      "title": "Meeting",          // Notification title
      "message": "Team sync",      // Notification message
      "type": "scheduled",         // Type: scheduled/recurring/instant
      "time": "14:00",            // For scheduled notifications
      "interval_minutes": 60,      // For recurring notifications
      "status": "active",          // Status: active/completed/cancelled
      "created_at": "2026-04-26T10:15:00",
      "template_name": "Weekly Meeting"  // Optional
    }
  ],
  "templates": [
    {
      "name": "Daily Standup",     // Template name
      "type": "scheduled",         // Template type
      "time": "09:30",            // Template time
      "title": "Daily Standup",    // Default title
      "message": "Morning sync",   // Default message
      "use_count": 15             // Usage tracking
    }
  ]
}

Key fields:

• id - Unique identifier (e.g., notif_001)

• type - scheduled, recurring, instant, countdown

• status - active, completed, cancelled

• created_at - When notification was created

• template_name - Links to template (optional)

Understanding Notification States

Notification lifecycle:

Created → Active → Completed
           ↓
       Cancelled

State definitions:

Active:

• Scheduled in the future

• Currently recurring

• Waiting to be sent

Completed:

• Already sent

• Countdown finished

• One-time notification done

Cancelled:

• User manually cancelled

• Removed before sending

State transitions:

# Create notification
notification['status'] = 'active'

# Send notification
notification['status'] = 'completed'
notification['completed_at'] = datetime.now().isoformat()

# Cancel notification
notification['status'] = 'cancelled'
notification['cancelled_at'] = datetime.now().isoformat()

Understanding Templates

What are templates?

Templates are saved notification configurations you can reuse:

# Template
{
  "name": "Daily Standup",
  "type": "scheduled",
  "time": "09:30",
  "title": "Daily Standup",
  "message": "Morning team sync"
}

# Create from template
notification = create_from_template("Daily Standup")
# Automatically fills in all fields

Template benefits:

✅ Consistency - Same notification every time
✅ Speed - One click instead of typing
✅ Tracking - See which templates are most used
✅ Reusability - Use same reminder daily/weekly

Common templates:

• Daily standup (9:30 AM)

• Lunch break (12:00 PM)

• End of workday (5:00 PM)

• Hydration reminder (every 1 hour)

• Pomodoro session (25 minute timer)

Understanding Notification IDs

Why unique IDs?

Need a way to identify specific notifications:

# Without IDs - ambiguous!
cancel_notification("Team Meeting")  # Which one?

# With IDs - precise!
cancel_notification("notif_001")  # Exact notification

ID generation:

def generate_id(self):
    # Get highest existing ID number
    existing_ids = [n['id'] for n in self.notifications]
    
    if not existing_ids:
        return "notif_001"
    
    # Extract numbers and increment
    numbers = [int(id.split('_')[1]) for id in existing_ids]
    next_num = max(numbers) + 1
    
    return f"notif_{next_num:03d}"

Understanding Multi-Notification Management

Managing multiple scheduled notifications:

# Track all active threads
active_threads = []

# Start notification 1
thread1 = threading.Thread(target=send_later, args=("notif_001",))
thread1.start()
active_threads.append(thread1)

# Start notification 2
thread2 = threading.Thread(target=send_later, args=("notif_002",))
thread2.start()
active_threads.append(thread2)

# Both running simultaneously!

Cancelling specific notifications:

# Each thread has reference to notification ID
# Store stop flags in dictionary

stop_flags = {}

def send_later(notif_id):
    while not stop_flags.get(notif_id, False):
        # Wait and check if cancelled
        time.sleep(1)
    
    # Send notification
    send_notification(...)

# To cancel
stop_flags[notif_id] = True

Understanding Auto-Reload on Startup

Resume notifications on startup:

def load_and_schedule(self):
    # Load from JSON
    data = self.load_data()
    
    # Find active scheduled notifications
    for notif in data['notifications']:
        if notif['status'] == 'active':
            if notif['type'] == 'scheduled':
                # Reschedule if time hasn't passed
                self._reschedule_notification(notif)
            elif notif['type'] == 'recurring':
                # Restart recurring reminder
                self._restart_recurring(notif)

What gets rescheduled:

✅ Scheduled notifications - If time is in future
✅ Recurring reminders - Always restart
❌ Completed notifications - Already sent
❌ Past scheduled times - Mark as missed

What You’ve Accomplished This Week

• Day 1: Desktop notifications with cross-platform support

• Day 2: Scheduling, timers, and Pomodoro

• Day 3: Persistence, templates, and full management

You now have:

✅ Cross-platform notifications - Works on Mac, Windows, Linux
✅ Flexible scheduling - Instant, scheduled, recurring, countdown
✅ Persistent storage - Survives program restarts
✅ Template system - Reusable notification configs
✅ Full management - Create, list, cancel, edit
✅ Production-ready - Clean code, error handling, JSON storage

View Code Evolution

Compare today’s full management system with earlier versions and see how we evolved from simple notifications → scheduling → complete persistence.

Read more

This week, we build a Desktop Notification System that displays toast notifications, schedules reminders, and manages alerts — perfect for building productivity tools!

• Day 1: Simple Desktop Notifications

• Day 2: Scheduled Notifications & Timers (Today)

• Day 3: Smart Notification Manager with Persistence

View All Projects This Week

Today’s Project

Yesterday we built basic notifications. Today we’re adding time-based features — schedule notifications for specific times, create countdown timers, and build a Pomodoro work timer!

You’ll learn scheduling, time calculations, threading, and building productivity tools that notify you at the right moment!

Project Task

Enhance the notification system with time-based features:

• Schedule notifications for specific times

• Countdown timers with notifications

• Recurring reminders (every X minutes)

• Pomodoro timer (25 min work + 5 min break)

• Time parsing (natural language like “5pm”, “30 minutes”)

• Background task scheduling

• Visual countdown display

• All Day 1 features still work

This project gives you hands-on practice with scheduling, datetime parsing, threading, timers, background tasks, and building productivity tools — essential skills for automation and time-based applications!

Expected Output

Running the enhanced notification system:

python solution.py

Console Output:

Here is what the user sees in the console when running the program:

In the interaction above the user has chosen to use the Pomodoro feature. After 25 minutes have elapsed, the user will get a native desktop notification:

After some minutes, another focus session will start.

Setup Instructions

No new installations needed!

Same setup as Day 1:

macOS:

python solution.py

Windows:

pip install win10toast  # If not already installed
python solution.py

Linux:

python solution.py

Understanding Time-Based Scheduling

Three types of scheduling:

1. Absolute time (schedule_at):

# Notify at 3:00 PM today
scheduler.schedule_at("15:00", "Meeting", "Daily standup")

2. Relative time (countdown):

# Notify in 25 minutes
scheduler.countdown_timer(25, "Timer Done", "Break time!")

3. Recurring (repeating):

# Notify every 30 minutes
scheduler.recurring_reminder(30, "Reminder", "Drink water")

Understanding Datetime Parsing

Converting user input to datetime objects:

from datetime import datetime, timedelta

# Parse "15:00" to today at 3 PM
def parse_time(time_str):
    # Split "15:00" into hours and minutes
    hours, minutes = map(int, time_str.split(':'))
    
    # Get today's date
    now = datetime.now()
    
    # Combine with specified time
    scheduled_time = now.replace(hour=hours, minute=minutes, second=0)
    
    # If time already passed today, schedule for tomorrow
    if scheduled_time < now:
        scheduled_time += timedelta(days=1)
    
    return scheduled_time

Calculating time until notification:

# How long until 3 PM?
now = datetime.now()
scheduled_time = parse_time("15:00")

time_diff = scheduled_time - now

# Convert to readable format
hours = time_diff.seconds // 3600
minutes = (time_diff.seconds % 3600) // 60

print(f"Time until notification: {hours} hours {minutes} minutes")

Understanding Threading for Background Tasks

Why threading?

Without threading, your program blocks while waiting:

# BAD - Program freezes for 25 minutes!
time.sleep(25 * 60)
send_notification("Timer Done", "Break time!")
# User can't do anything else during wait

With threading, program stays responsive:

import threading

def timer_thread(minutes):
    time.sleep(minutes * 60)
    send_notification("Timer Done", "Break time!")

# Start timer in background
thread = threading.Thread(target=timer_thread, args=(25,))
thread.start()

# Program continues - user can start another timer!

Our approach:

def countdown_timer(self, minutes, title, message):
    # Create background thread
    thread = threading.Thread(
        target=self._run_countdown,
        args=(minutes, title, message)
    )
    thread.daemon = True  # Thread dies when main program exits
    thread.start()

Understanding the Pomodoro Technique

What is Pomodoro?

A productivity method that uses timed work sessions with breaks:

1. Work for 25 minutes (focused)

2. Break for 5 minutes (short)

3. Repeat 4 times

4. Long break 15-30 minutes

Our implementation:

def start_pomodoro(self, sessions=4):
    for i in range(sessions):
        # Work session
        print(f"🍅 Work Session {i+1}/{sessions}")
        self.countdown_timer(25, "Work Complete", "Time for a break!")
        
        # Short break (except after last session)
        if i < sessions - 1:
            print("☕ Break Time")
            self.countdown_timer(5, "Break Over", "Back to work!")

Why it works:

• ✅ Maintains focus with time limits

• ✅ Prevents burnout with regular breaks

• ✅ Creates rhythm and routine

• ✅ Notifications keep you on track

Understanding Countdown Display

Live countdown in terminal:

import time

def show_countdown(minutes):
    total_seconds = minutes * 60
    
    for remaining in range(total_seconds, 0, -60):
        mins = remaining // 60
        secs = remaining % 60
        
        # Display with carriage return (overwrites line)
        print(f"\r⏱️  Time remaining: {mins}:{secs:02d}", end='', flush=True)
        
        time.sleep(60)  # Wait 1 minute
    
    print("\n🔔 Timer complete!")

Key techniques:

• \r - Carriage return (moves cursor to start of line)

• end='' - Don’t print newline

• flush=True - Force immediate output

• Result: Counter updates in place instead of printing new lines

Understanding Recurring Reminders

How recurring reminders work:

def recurring_reminder(self, interval_minutes, title, message):
    while True:
        # Wait for interval
        time.sleep(interval_minutes * 60)
        
        # Send reminder
        self.send_notification(title, message)
        
        # Calculate next reminder time
        next_time = datetime.now() + timedelta(minutes=interval_minutes)
        print(f"Next reminder: {next_time.strftime('%I:%M %p')}")

Stopping recurring reminders:

# Use Ctrl+C to stop
try:
    recurring_reminder(30, "Break", "Take a break!")
except KeyboardInterrupt:
    print("\nRecurring reminder stopped.")

Practical Use Cases

1. Meeting reminders:

# Remind 15 minutes before 2 PM meeting
scheduler.schedule_at("13:45", "Meeting Soon", "Team sync at 2 PM")

2. Pomodoro work sessions:

# Deep work with automatic breaks
scheduler.start_pomodoro(sessions=4)

3. Hydration reminders:

# Drink water every hour
scheduler.recurring_reminder(60, "Hydration", "Drink some water!")

4. Cooking timers:

# Pasta cooking timer
scheduler.countdown_timer(10, "Pasta Ready", "Time to drain the pasta!")

5. Long-running script notifications:

# Start training ML model
train_model()  # Takes 3 hours

# Schedule notification for when it should be done
scheduler.countdown_timer(180, "Training Complete", "Model training finished!")

Coming Tomorrow

Tomorrow we’re building a Smart Notification Manager with persistence — save your scheduled notifications, create notification templates, manage multiple reminders, and run everything from the system tray!

View Code Evolution

Compare today’s scheduler-enhanced system with yesterday’s basic notifications and see how we added time-based features.

Read more

This week, we build a Desktop Notification System that displays toast notifications, schedules reminders, and manages alerts — perfect for building productivity tools!

Why build this? Because notifications are everywhere — apps, websites, productivity tools. You’ll learn how to create professional desktop alerts that grab attention at the right moment!

What you’ll learn: This series teaches you desktop notifications, system tray integration, scheduling, time-based triggers, persistence, and building tools that run in the background — essential skills for automation and productivity apps!

Why users love this: Create reminders that actually work! No more forgetting tasks or missing deadlines. By Day 3, you’ll have a smart notification manager running silently in your system tray!

• Day 1: Simple Desktop Notifications (Today)

• Day 2: Scheduled Notifications & Timers

• Day 3: Smart Notification Manager with Persistence

View All Projects This Week

Today’s Project

We’re starting with the foundation: a simple notification system that displays desktop toast notifications with custom messages, titles, and durations!

You’ll learn how to trigger system notifications from Python using native OS capabilities — no complex dependencies!

Project Task

Create a desktop notification system that:

• Displays toast notifications on Windows/Mac/Linux

• Custom title and message

• Adjustable duration (how long it shows)

• Multiple notification types (info, warning, success, error)

• Simple command-line interface

• Cross-platform compatibility

• Uses native OS notification systems

• No complex dependencies

This project gives you hands-on practice with desktop notifications, system integration, cross-platform development, user alerts, and building tools that interact with the operating system — essential for automation and productivity apps!

Expected Output

Running the notification tool:

python solution.py

Console Output:

That would trigger a notification on your computer:

Setup Instructions

Install Required Packages:

macOS and Linux (no installation needed!)

Windows:

pip install win10toast

Platform support:

• ✅ macOS - Native notification center via osascript

• ✅ Windows 10/11 - Native toast notifications via win10toast

• ✅ Linux - Native notifications via notify-send

Understanding Desktop Notifications

What are desktop notifications?

Desktop notifications (also called “toast notifications”) are small popup messages that appear on your screen to alert you about events, updates, or reminders.

Common uses:

• Email notifications

• Chat messages

• Reminders and alarms

• Task completions

• System alerts

• Download completions

How they work:

Your Python Script → Native OS API → Desktop Notification

Example flow:

# 1. Your code
notifier.send_notification("Download Complete", "file.zip is ready!")

# 2. Platform detection
# macOS: Uses osascript
# Windows: Uses win10toast
# Linux: Uses notify-send

# 3. OS displays notification
# User sees popup on screen

Understanding Cross-Platform Notifications

Why we detect the platform:

Different operating systems have different notification systems. Our code automatically detects your OS and uses the right method!

macOS approach:

# Uses AppleScript via osascript command
osascript -e 'display notification "message" with title "title"'

Windows approach:

# Uses Windows Toast Notification API
from win10toast import ToastNotifier
toaster = ToastNotifier()
toaster.show_toast("Title", "Message")

Linux approach:

# Uses notify-send (part of libnotify)
notify-send "Title" "Message" -t 5000

Our unified approach:

def send_notification(self, title, message, duration=5):
    if self.platform == "Darwin":  # macOS
        self._send_macos_notification(title, message)
    elif self.platform == "Windows":
        self._send_windows_notification(title, message, duration)
    elif self.platform == "Linux":
        self._send_linux_notification(title, message, duration)

Benefits:

• ✅ Same code works everywhere

• ✅ No complex dependencies

• ✅ Uses native OS features

• ✅ Looks native on each platform

Understanding Notification Parameters

Title:

• Short, attention-grabbing text

• Appears in bold at the top

• Keep under 50 characters

• Example: “Download Complete”, “New Message”, “Reminder”

Message:

• Main notification content

• Can be longer (up to 200 characters recommended)

• Should be clear and actionable

• Example: “Your file download.zip is ready to use”

Duration:

• How long notification stays on screen (seconds)

• Default: 5-10 seconds

• Short messages: 5 seconds

• Important messages: 10+ seconds

• Note: macOS ignores duration and uses system default

App Name:

• Identifies which app sent the notification

• Appears at bottom of notification

• Example: “Python Notifier”, “My Reminder App”

Understanding Notification Types

We implement different notification types with emoji indicators:

1. Info Notification (ℹ️):

notifier.send_info(
    title="Information",
    message="This is an informational message"
)
# Displays: ℹ️ Information

2. Success Notification (✅):

notifier.send_success(
    title="Success!",
    message="Operation completed successfully"
)
# Displays: ✅ Success!

3. Urgent Notification (⚠️):

notifier.send_urgent(
    title="Warning",
    message="Action required!"
)
# Displays: ⚠️ Warning

4. Error Notification (❌):

notifier.send_error(
    title="Error",
    message="Something went wrong"
)
# Displays: ❌ Error

Why emojis?

• ✅ Universal visual indicators

• ✅ Work on all platforms

• ✅ No icon files needed

• ✅ Instant recognition

Practical Use Cases

1. Long-running scripts:

# Scraping script
scraper.run()  # Takes 30 minutes

# Notify when done
notifier.send_success(
    "Scraping Complete",
    "Collected 1,500 quotes successfully!"
)

2. File downloads:

download_file(url)

notifier.send_notification(
    "Download Complete",
    f"{filename} is ready!"
)

3. Task reminders:

notifier.send_notification(
    "Break Time!",
    "You've been working for 1 hour. Take a 5-minute break."
)

4. System monitoring:

if disk_space < 10:
    notifier.send_urgent(
        "Low Disk Space",
        f"Only {disk_space}% remaining!"
    )

5. Build/test completions:

run_tests()

if all_passed:
    notifier.send_success("Tests Passed", "All 47 tests passed!")
else:
    notifier.send_error("Tests Failed", f"{failed_count} tests failed")

Coming Tomorrow

Tomorrow we’re adding scheduled notifications and timers — set reminders for specific times, create countdown timers, and build a Pomodoro-style work timer with automatic notifications!

Skeleton and Solution

Below you will find both a downloadable skeleton.py file to help you code the project with comment guides and the downloadable solution.py file containing the correct solution.

Get the code skeleton here:

View Code Skeleton

Get the code solution here:

View Code Solution

This week, we learn Object-Oriented Programming (OOP) by building a web scraper that evolves from functions to classes to inheritance.

• Day 1: Quote Scraper with Functions

• Day 2: Refactoring to Classes

• Day 3: Adding Inheritance & Multiple Scrapers (Today)

View All Projects This Week

Today’s Project

Welcome to the finale! Yesterday we refactored to classes. Today we’re taking it further with inheritance — creating a base Scraper class and two specialized scrapers that inherit from it!

You’ll build QuoteScraper and AuthorScraper — both share common scraping logic but extract different data. This is how professional code reuses functionality!

Project Task

Create a scraping system with inheritance that:

• Base Scraper class with common scraping logic

• QuoteScraper inherits from Scraper (extracts quotes)

• AuthorScraper inherits from Scraper (extracts authors)

• Shared methods in base class (fetch, scrape, save)

• Specialized parsing in each subclass

• Both scrapers work independently

• Demonstrates clean code reuse

This project gives you hands-on practice with inheritance, base classes, method overriding, code reuse, and OOP design — essential skills for building maintainable applications!

Expected Output

Running the scraper:

python solution.py

Console Output:

The scraper scrapes quotes like in Day 2 but in addition, it also scrapes other data such as authors:

Setup Instructions

Install Required Packages:

pip install requests beautifulsoup4

Run the scrit:

python solution.py

Understanding Inheritance

What is inheritance?

Inheritance lets you create a base class with common functionality, then create child classes that inherit and extend that functionality.

Our hierarchy:

        Scraper (Base Class)
           ↑
           |
    ┌──────┴──────┐
    |             |
QuoteScraper  AuthorScraper

Before inheritance (repetitive):

class QuoteScraper:
    def fetch_page(self, url):
        # Fetching logic
        pass
    
    def scrape(self):
        # Pagination logic
        pass
    
    def parse_quotes(self, html):
        # Different!
        pass

class AuthorScraper:
    def fetch_page(self, url):
        # DUPLICATE CODE!
        pass
    
    def scrape(self):
        # DUPLICATE CODE!
        pass
    
    def parse_authors(self, html):
        # Different!
        pass

After inheritance (clean):

class Scraper:
    """Base class - write once, use everywhere"""
    def fetch_page(self, url):
        # Common code
        pass
    
    def scrape(self):
        # Common code
        pass

class QuoteScraper(Scraper):
    """Inherits fetch_page and scrape"""
    def parse_data(self, html):
        # Only write the unique part
        pass

class AuthorScraper(Scraper):
    """Also inherits fetch_page and scrape"""
    def parse_data(self, html):
        # Only write the unique part
        pass

Understanding the Base Scraper Class

The base class contains what’s shared:

class Scraper:
    """Base scraper with common functionality"""
    
    def __init__(self, base_url, max_pages=3):
        self.base_url = base_url
        self.max_pages = max_pages
        self.data = []
    
    def fetch_page(self, url):
        """Fetch HTML - same for all scrapers"""
        response = requests.get(url)
        return response.text
    
    def scrape(self):
        """Scrape pages - same logic for all scrapers"""
        for page_num in range(1, self.max_pages + 1):
            url = f"{self.base_url}/page/{page_num}/"
            html = self.fetch_page(url)
            
            # Call parse_data (implemented by child)
            data = self.parse_data(html)
            
            self.data.extend(data)
    
    def save_to_json(self, filename):
        """Save data - same for all scrapers"""
        with open(filename, 'w') as f:
            json.dump(self.data, f)
    
    def parse_data(self, html):
        """Must be implemented by child classes"""
        raise NotImplementedError("Child must implement parse_data()")

Key points:

✅ fetch_page() - All scrapers fetch HTML the same way
✅ scrape() - All scrapers loop through pages the same way
✅ save_to_json() - All scrapers save files the same way
✅ parse_data() - Each child implements differently

Understanding Child Classes

QuoteScraper - extracts quotes:

class QuoteScraper(Scraper):
    """Inherits from Scraper"""
    
    def __init__(self, base_url, tags_filter, max_pages=3):
        super().__init__(base_url, max_pages)  # Call parent init
        self.tags_filter = tags_filter
    
    def parse_data(self, html):
        """Parse quotes - unique to this scraper"""
        soup = BeautifulSoup(html, 'html.parser')
        quotes = soup.find_all('div', class_='quote')
        
        results = []
        for quote in quotes:
            text = quote.find('span', class_='text').text
            author = quote.find('small', class_='author').text
            tags = [tag.text for tag in quote.find_all('a', class_='tag')]
            
            # Filter by tags
            if any(tag in self.tags_filter for tag in tags):
                results.append({
                    'text': text,
                    'author': author,
                    'tags': tags
                })
        
        return results

AuthorScraper - counts authors:

class AuthorScraper(Scraper):
    """Also inherits from Scraper"""
    
    def parse_data(self, html):
        """Parse authors - unique to this scraper"""
        soup = BeautifulSoup(html, 'html.parser')
        authors = soup.find_all('small', class_='author')
        
        # Just return author names
        return [author.text for author in authors]

What they inherit:

• ✅ fetch_page() from Scraper

• ✅ scrape() from Scraper

• ✅ save_to_json() from Scraper

What they implement:

• 🆕 parse_data() - unique to each scraper

Understanding super()

super() calls the parent class:

class QuoteScraper(Scraper):
    def __init__(self, base_url, tags_filter, max_pages=3):
        # Call parent's __init__ first
        super().__init__(base_url, max_pages)
        
        # Then add child-specific attributes
        self.tags_filter = tags_filter

What happens:

scraper = QuoteScraper("http://example.com", ['life'], max_pages=3)

# Step 1: super().__init__(base_url, max_pages)
#   → self.base_url = "http://example.com"
#   → self.max_pages = 3
#   → self.data = []

# Step 2: Child __init__ continues
#   → self.tags_filter = ['life']

# Result: All attributes set!

Why Inheritance Matters

What we gain:

1. Write once, use everywhere:

# fetch_page() written ONCE in Scraper
# Both QuoteScraper and AuthorScraper use it

2. Easy to add new scrapers:

class TagScraper(Scraper):
    def parse_data(self, html):
        # Only implement the unique part!
        # Everything else inherited
        pass

3. Fix bugs in one place:

# Bug in fetch_page()?
# Fix it in Scraper class
# All children benefit automatically!

4. Consistent behavior:

# All scrapers fetch pages the same way
# All scrapers handle pagination the same way
# All scrapers save files the same way

Code Comparison: Day 2 vs Day 3

Day 2 (Single QuoteScraper class):

• ✅ Better than functions

• ❌ Can’t reuse for other scrapers

• ❌ Would duplicate code for AuthorScraper

Day 3 (Inheritance):

• ✅ Base class holds common code

• ✅ Easy to add new scrapers

• ✅ No code duplication

• ✅ Fix once, benefit everywhere

What You’ve Accomplished This Week

🎉 Congratulations! You’ve completed the OOP journey!

• Day 1: Functions - Simple and procedural

• Day 2: Classes - Organized with encapsulation

• Day 3: Inheritance - Reusable and scalable

You now understand:

✅ Functions → Small, independent tasks
✅ Classes → Grouping related data and behavior
✅ Inheritance → Sharing code across similar classes

This is how professional Python is written!

Real-world examples of inheritance:

• Games: Character → Player, Enemy, NPC

• Web frameworks: View → ListView, DetailView, CreateView

• ML models: Model → LinearRegression, DecisionTree, NeuralNetwork

• Data processing: FileReader → CSVReader, JSONReader, XMLReader

You’ve mastered the fundamentals of OOP! 🚀

View Code Evolution

Compare today’s inheritance-based system with earlier versions and see how we evolved from functions → classes → inheritance for maximum code reuse.

Read more

This week, we learn Object-Oriented Programming (OOP) by building a web scraper that evolves from functions to classes to inheritance.

• Day 1: Quote Scraper with Functions

• Day 2: Refactoring to Classes (Today)

• Day 3: Adding Inheritance & Multiple Scrapers

View All Projects This Week

Today’s Project

Yesterday we built a quote scraper using only functions. Today we’re refactoring the exact same scraper using classes!

You’ll see the same functionality, but organized as a QuoteScraper class. This is your “aha moment” for understanding why and when to use classes instead of functions!

Project Task

Refactor yesterday’s scraper into a class-based design that:

• Same functionality as Day 1 (scrape, filter, save)

• Organized as a QuoteScraper class

• Instance variables store configuration and state

• Methods replace standalone functions

• Cleaner data flow with self

• Easier to extend and maintain

• Same output as Day 1

This project gives you hands-on practice with class design, instance variables, methods, self keyword, refactoring, and object-oriented thinking — the foundation of professional Python code!

Expected Output

Running the scraper:

python solution.py

Console Output:

The output is the same as the output of Day 1. We get the quotes displayed. So, the behavior of the program does not change. It is only the code that changes:

Setup Instructions

Install Required Packages:

pip install requests beautifulsoup4

Same packages as Day 1!

Run the scraper:

python solution.py

Same output as Day 1, but now it’s organized as a class!

Understanding Classes vs Functions

Yesterday (Functions):

# Pass data between functions
html = fetch_page(url)
quotes = parse_quotes(html)
filtered = filter_by_tags(quotes, tags_filter)
save_to_json(filtered, tags_filter)

Problems:

• ❌ Pass tags_filter to every function

• ❌ No shared state

• ❌ Hard to track what data belongs together

• ❌ Difficult to extend

Today (Classes):

# Create instance with configuration
scraper = QuoteScraper(base_url=url, tags_filter=tags)

# Call methods - they share state via self
scraper.scrape()  # Uses self.base_url and self.tags_filter
scraper.save_to_json()  # Uses self.quotes

Benefits:

• ✅ Configuration stored once in self

• ✅ Shared state across methods

• ✅ Related data grouped together

• ✅ Easy to extend with new methods

Understanding the QuoteScraper Class

Class structure:

class QuoteScraper:
    def __init__(self, base_url, tags_filter):
        """Initialize the scraper with configuration"""
        self.base_url = base_url
        self.tags_filter = tags_filter
        self.quotes = []  # Store results here
    
    def fetch_page(self, url):
        """Fetch HTML from URL"""
        # Same logic as Day 1 function
        return html
    
    def parse_quotes(self, html):
        """Parse quotes from HTML"""
        # Same logic as Day 1 function
        return quotes
    
    def filter_by_tags(self, quotes):
        """Filter quotes by self.tags_filter"""
        # Uses self.tags_filter instead of parameter
        return filtered
    
    def scrape(self):
        """Main scraping method"""
        page = 1
        while True:
            url = f"{self.base_url}/page/{page}/"
            html = self.fetch_page(url)
            quotes = self.parse_quotes(html)
            filtered = self.filter_by_tags(quotes)
            self.quotes.extend(filtered)  # Store in self.quotes
            page += 1
    
    def save_to_json(self):
        """Save self.quotes to JSON"""
        # Uses self.quotes and self.tags_filter
        pass

Understanding self

What is self?

self refers to the instance of the class. It’s how methods access the instance’s data.

# Create an instance
scraper = QuoteScraper(
    base_url="http://quotes.toscrape.com",
    tags_filter=['life']
)

# When you call a method:
scraper.fetch_page(url)

# Python automatically passes the instance as 'self':
QuoteScraper.fetch_page(scraper, url)
#                       ^^^^^^
#                       This is 'self'!

Using self to share data:

class QuoteScraper:
    def __init__(self, tags_filter):
        self.tags_filter = tags_filter  # Store in instance
        self.quotes = []  # Shared across methods
    
    def scrape(self):
        # Access instance variables with self
        print(f"Filtering by: {self.tags_filter}")
        
        quotes = self.parse_quotes(html)
        filtered = self.filter_by_tags(quotes)
        
        # Store in instance variable
        self.quotes.extend(filtered)
    
    def filter_by_tags(self, quotes):
        # Use self.tags_filter instead of parameter!
        return [q for q in quotes if any(tag in self.tags_filter for tag in q['tags'])]
    
    def save_to_json(self):
        # Access self.quotes that scrape() filled
        data = {'quotes': self.quotes}
        # ...

Without self (doesn’t work):

class QuoteScraper:
    def __init__(self, tags_filter):
        tags_filter = tags_filter  # ❌ Local variable, lost after __init__
    
    def scrape(self):
        print(tags_filter)  # ❌ ERROR: tags_filter not defined!

Understanding Instance Variables

Instance variables = data that belongs to a specific instance.

Example:

# Create two different scrapers
scraper1 = QuoteScraper(tags_filter=['life'])
scraper2 = QuoteScraper(tags_filter=['humor'])

# Each has its own data!
print(scraper1.tags_filter)  # ['life']
print(scraper2.tags_filter)  # ['humor']

# Run both
scraper1.scrape()
scraper2.scrape()

# Each stores different quotes
print(len(scraper1.quotes))  # 20 life quotes
print(len(scraper2.quotes))  # 15 humor quotes

Common instance variables in our scraper:

def __init__(self, base_url, tags_filter):
    # Configuration (set once, used everywhere)
    self.base_url = base_url
    self.tags_filter = tags_filter
    
    # State (changes during execution)
    self.quotes = []  # Filled by scrape()
    self.current_page = 1  # Tracks pagination

Understanding Methods

Methods = functions that belong to a class.

Two types of methods in our scraper:

1. Public methods (meant to be called from outside):

class QuoteScraper:
    def scrape(self):
        """Main method - users call this"""
        # ...
    
    def save_to_json(self):
        """Save results - users call this"""
        # ...

2. Helper methods (used internally):

class QuoteScraper:
    def _fetch_page(self, url):
        """Internal helper - users don't call this directly"""
        # Underscore prefix = "private" by convention
        # ...
    
    def _parse_quotes(self, html):
        """Internal helper"""
        # ...

Calling methods:

# From outside the class
scraper = QuoteScraper(...)
scraper.scrape()  # Public method

# From inside the class (in another method)
class QuoteScraper:
    def scrape(self):
        html = self._fetch_page(url)  # Call helper method
        quotes = self._parse_quotes(html)  # Call another helper

Why Classes Are Better Here

Day 1 approach (functions):

# Problem: Pass everything everywhere
def main():
    tags = ['life', 'love']
    
    quotes = scrape_all_pages(BASE_URL, tags)
    filtered = filter_by_tags(quotes, tags)
    save_to_json(filtered, tags)
    
    # Want to scrape again with different tags?
    # Start over, pass everything again
    quotes2 = scrape_all_pages(BASE_URL, ['humor'])
    filtered2 = filter_by_tags(quotes2, ['humor'])
    save_to_json(filtered2, ['humor'])

Day 2 approach (classes):

# Solution: Create reusable objects
scraper1 = QuoteScraper(BASE_URL, ['life', 'love'])
scraper1.scrape()
scraper1.save_to_json()

scraper2 = QuoteScraper(BASE_URL, ['humor'])
scraper2.scrape()
scraper2.save_to_json()

# Easy to compare results
print(f"Life quotes: {len(scraper1.quotes)}")
print(f"Humor quotes: {len(scraper2.quotes)}")

Other benefits:

✅ Encapsulation - Related data and functions grouped together
✅ State management - self.quotes persists across method calls
✅ Reusability - Create multiple scraper instances
✅ Extensibility - Easy to add new methods tomorrow
✅ Clarity - Clear what data belongs to what

Coming Tomorrow

Tomorrow we’re adding inheritance! We’ll create a base Scraper class and inherit from it to create different scrapers (quotes, authors, tags). You’ll see how OOP makes it easy to reuse code across similar classes!

View Code Evolution

Compare today’s class-based solution with yesterday’s function-based version and see the differences in organization and structure.

Read more

This week, we learn Object-Oriented Programming (OOP) by building a web scraper that evolves from functions to classes to inheritance.

Why build this? Because OOP is how professional code is structured. You’ll see the same scraper written three ways — first with functions (today), then refactored to classes (Day 2), then enhanced with inheritance (Day 3). By the end, you’ll understand why classes matter!

What you’ll learn: This series teaches you function-based programming, class structures, object-oriented design, inheritance, code organization, and refactoring — essential skills for writing maintainable, professional Python code.

Why users love this: You’ll see the same project evolve from simple functions to elegant OOP. Perfect for understanding when and why to use classes instead of functions!

• Day 1: Quote Scraper with Functions (Today)

• Day 2: Refactoring to Classes

• Day 3: Adding Inheritance & Multiple Scrapers

View All Projects This Week

Today’s Project

We’re building a quote scraper that fetches quotes from quotes.toscrape.com, filters them by tag, and saves them to a JSON file. Today’s version uses pure functions — clean, simple, and procedural!

You’ll learn web scraping basics, HTML parsing, data filtering, and JSON storage!

Project Task

Create a quote scraper that:

• Scrapes quotes from quotes.toscrape.com

• Extracts quote text, author, and tags

• Filters quotes by specific tags (motivational, life, inspirational)

• Handles multiple pages of quotes

• Saves results to JSON file

• Clean console output showing progress

• Error handling for failed requests

• Uses only functions (no classes yet!)

This project gives you hands-on practice with web scraping, BeautifulSoup, requests library, data parsing, filtering, file I/O, and functional programming — all the foundations you need before learning OOP!

Expected Output

Running the scraper:

python solution.py

Console Output:

Running the program will print out the progress of the scraper as below:

Below that you will see the quotes scraped and printed out:

Generated JSON file: quotes_motivational_life_inspirational.json

In addition to printing out the scraped content, the program will also save the data in a JSON file:

Setup Instructions

Install Required Packages:

pip install requests beautifulsoup4

What each package does:

• requests - Makes HTTP requests to fetch web pages

• beautifulsoup4 - Parses HTML and extracts data

Run the scraper:

python solution.py

The scraper will:

1. Fetch quotes from quotes.toscrape.com

2. Filter by tags: motivational, life, inspirational

3. Save results to JSON file

4. Show progress in console

You can modify the tags in the script to scrape different quotes!

Understanding Web Scraping Basics

What is web scraping?

Web scraping is extracting data from websites by:

1. Sending HTTP request to get the HTML

2. Parsing the HTML to find specific elements

3. Extracting the data you need

4. Storing it in a structured format

The scraping workflow:

URL → HTTP Request → HTML Response → Parse HTML → Extract Data → Save to File

Example HTML structure from quotes.toscrape.com:

<div class="quote">
  <span class="text">"The world as we have created it..."</span>
  <small class="author">Albert Einstein</small>
  <div class="tags">
    <a class="tag">change</a>
    <a class="tag">inspirational</a>
    <a class="tag">life</a>
  </div>
</div>

How we extract it:

import requests
from bs4 import BeautifulSoup

# 1. Fetch the page
response = requests.get('http://quotes.toscrape.com/page/1/')
html = response.text

# 2. Parse HTML
soup = BeautifulSoup(html, 'html.parser')

# 3. Find all quote divs
quotes = soup.find_all('div', class_='quote')

# 4. Extract data from each quote
for quote in quotes:
    text = quote.find('span', class_='text').text
    author = quote.find('small', class_='author').text
    tags = [tag.text for tag in quote.find_all('a', class_='tag')]

Why quotes.toscrape.com?

This website is specifically designed for learning web scraping:

• ✅ Simple, clean HTML structure

• ✅ No anti-scraping measures

• ✅ Paginated data (multiple pages)

• ✅ Different data types (text, authors, tags)

• ✅ Legal and ethical to scrape

Understanding BeautifulSoup

BeautifulSoup is a Python library that makes HTML parsing easy.

Key methods we use:

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'html.parser')

# Find first matching element
quote = soup.find('div', class_='quote')

# Find all matching elements
quotes = soup.find_all('div', class_='quote')

# Get text content
text = element.text

# Get attribute value
href = element.get('href')

CSS class selector:

# Find by class name
soup.find('div', class_='quote')

# Find by ID
soup.find('div', id='my-id')

# Find by tag name
soup.find('span')

Navigating the HTML tree:

# Find nested elements
quote = soup.find('div', class_='quote')
author = quote.find('small', class_='author')

# Find multiple nested elements
tags = quote.find_all('a', class_='tag')

Understanding Pagination

What is pagination?

Websites split data across multiple pages:

• Page 1: quotes.toscrape.com/page/1/

• Page 2: quotes.toscrape.com/page/2/

• Page 3: quotes.toscrape.com/page/3/

• ...

How we handle it:

page_num = 1
has_more_pages = True

while has_more_pages:
    url = f'http://quotes.toscrape.com/page/{page_num}/'
    response = requests.get(url)
    
    # Check if page exists
    if response.status_code == 404:
        has_more_pages = False
        break
    
    # Scrape this page
    quotes = scrape_page(url)
    
    # Move to next page
    page_num += 1

Detecting the last page:

We know we’re on the last page when:

• HTTP status code is 404 (page not found)

• Or there’s no “Next” button in the HTML

• Or we find 0 quotes on the page

Understanding Function-Based Design

Today’s architecture uses only functions:

# Each function does ONE thing

def fetch_page(url):
    """Fetch HTML from URL"""
    return html

def parse_quotes(html):
    """Extract quotes from HTML"""
    return quotes

def filter_by_tags(quotes, tags):
    """Filter quotes by tags"""
    return filtered_quotes

def save_to_json(quotes, filename):
    """Save quotes to JSON file"""
    # write to file

Why functions first?

✅ Simple to understand
✅ Easy to test each piece
✅ Clear data flow
✅ Good for small projects

Limitations we’ll see tomorrow:

❌ No shared state (passing data everywhere)
❌ Difficult to extend functionality
❌ Hard to manage related data
❌ No encapsulation

Tomorrow we’ll refactor to classes and see how OOP solves these problems!

Coming Tomorrow

Tomorrow we’re refactoring this exact code to use classes! You’ll see how the same scraper becomes cleaner, more organized, and easier to extend when we introduce OOP concepts like encapsulation and methods!

Skeleton and Solution

Below you will find both a downloadable skeleton.py file to help you code the project with comment guides and the downloadable solution.py file containing the correct solution.

Get the code skeleton here:

View Code Skeleton

Get the code solution here:

View Code Solution

This week, we build a real-world Weather Data API from scratch using Flask, teaching you how APIs work by building one yourself.

• Day 1: Basic Weather API with Flask

• Day 2: POST Requests & Data Storage

• Day 3: API Key Authentication (Today)

View All Projects This Week

Today’s Project

Welcome to the finale! We’ve built a working API with GET and POST endpoints. Today we’re adding API key authentication — the security layer that protects your API and controls who can access it!

You’ll learn how real-world APIs like Stripe, OpenAI, and Google Maps protect their endpoints and track usage!

Project Task

Create a production-ready Weather API with authentication that:

• Generates unique API keys for users

• Protects endpoints with API key validation

• Tracks API usage per key

• Implements rate limiting (requests per hour)

• Stores API keys securely

• Returns proper authentication errors

• Allows key generation via endpoint

• Shows usage statistics

• Production-ready security

This project gives you hands-on practice with API authentication, security best practices, rate limiting, usage tracking, middleware patterns, and building professional APIs — essential skills for real-world backend development!

Expected Output

RUNNING THE API:

As the developer of the API you can run it with:

python solution.py

USING THE API

Users who want to use your API, first need to generate an API key. They can do so by running this generate_key.py: file:

import requests

# Generate a new API key
response = requests.post(
    'http://127.0.0.1:5000/auth/generate-key',
    json={'name': 'My Weather App'}
)

result = response.json()
print("\n" + "="*50)
print("API KEY GENERATED!")
print("="*50)
print(f"\nYour API Key: {result['api_key']}")
print(f"\nApp Name: {result['name']}")
print(f"Rate Limit: {result['rate_limit']} requests/hour")
print(f"Created: {result['created_at']}")
print("\n⚠️  SAVE THIS KEY - You'll need it for all requests!")
print("="*50 + "\n")

Run it:

python generate_key.py

Output:

==================================================
API KEY GENERATED!
==================================================

Your API Key: wapi_a8f3c2e1b9d4f6a7c3e8b2d9f1a4c6e3

App Name: My Weather App
Rate Limit: 100 requests/hour
Created: 2026-04-24T10:30:00

⚠️  SAVE THIS KEY - You'll need it for all requests!
==================================================

Clients using the API key to get weather

Once users have the API key, they can use it in a program (this program is known as the client). For example, here is a script that consumes the API and provides the API key in the script to be able to access the API data:

import requests

# Your API key from Step 1
API_KEY = "wapi_a8f3c2e1b9d4f6a7c3e8b2d9f1a4c6e3"

# Set up headers with your API key
headers = {
    "X-API-Key": API_KEY
}

# Get weather for New York
print("\nGetting weather for New York...")
response = requests.get(
    'http://127.0.0.1:5000/weather/newyork',
    headers=headers
)

weather = response.json()
print(f"\nCity: {weather['city']}")
print(f"Temperature: {weather['temperature']}°{weather['unit'][0].upper()}")
print(f"Conditions: {weather['conditions']}")
print(f"Humidity: {weather['humidity']}%")
print(f"Wind Speed: {weather['wind_speed']} mph")

Output:

Getting weather for New York...

City: New York
Temperature: 72°F
Conditions: Partly Cloudy
Humidity: 65%
Wind Speed: 12 mph

Submit weather data

Users can also submit data. Here is a script that does that:

# Submit new weather report
print("\n📤 Submitting weather report for Seattle...")

weather_data = {
    "city": "Seattle",
    "temperature": 60,
    "unit": "fahrenheit",
    "conditions": "Rainy",
    "humidity": 85,
    "wind_speed": 15
}

response = requests.post(
    'http://127.0.0.1:5000/weather/submit',
    headers=headers,
    json=weather_data
)

result = response.json()
print(f"\n✅ {result['message']}")
print(f"Report ID: {result['data']['report_id']}")
print(f"Timestamp: {result['data']['timestamp']}")

Output:

📤 Submitting weather report for Seattle...

✅ Weather report submitted successfully
Report ID: seattle_20260424_103700
Timestamp: 2026-04-24T10:37:00

Check your API usage

Users can also check their usage statistics of the API from their end:

# Check usage statistics
print("\n📊 Checking API usage...")

response = requests.get(
    'http://127.0.0.1:5000/auth/usage',
    headers=headers
)

usage = response.json()
print(f"\nApp: {usage['name']}")
print(f"Total Requests: {usage['usage']['total_requests']}")
print(f"Last Hour: {usage['usage']['requests_last_hour']}")
print(f"Remaining: {usage['usage']['remaining']}/{usage['usage']['rate_limit']}")
print(f"Last Used: {usage['last_used']}")

Output:

📊 Checking API usage...

App: My Weather App
Total Requests: 15
Last Hour: 3
Remaining: 97/100
Last Used: 2026-04-24T10:37:00

What happens without an API key?

If a user accesses the API without the header:

# No API key - this will fail!
response = requests.get('http://127.0.0.1:5000/weather/london')
print(response.json())

the output will be an error message inside the JSON output:

{
  "error": "Unauthorized",
  "message": "API key is required. Include 'X-API-Key' header in your request.",
  "example": "X-API-Key: your_api_key_here"
}

What happens when you exceed the rate limit?

After 100 requests in one hour:

# 101st request
response = requests.get(
    'http://127.0.0.1:5000/weather/paris',
    headers=headers
)
print(response.json())

Output:

{
  "error": "Rate limit exceeded",
  "message": "You have exceeded 100 requests per hour",
  "retry_after": "52 minutes",
  "limit": 100
}

Understanding API Key Authentication

What is an API key?

An API key is a unique identifier that:

• ✅ Identifies who is making the request

• ✅ Controls access to your API

• ✅ Tracks usage per user/app

• ✅ Enables rate limiting

• ✅ Can be revoked if abused

Real-world examples:

OpenAI API: sk-proj-abc123...
Google Maps: AIzaSyD...
Stripe: sk_live_51H...

Our format: wapi_ prefix + 32 random hex characters

How it works:

Your Python Script:
  headers = {"X-API-Key": "wapi_abc123..."}
  requests.get(url, headers=headers)
           ↓
Your Flask API:
  1. Check if X-API-Key header exists → No? Return 401
  2. Validate key in api_keys.json → Invalid? Return 401
  3. Check rate limit → Exceeded? Return 429
  4. Log usage
  5. Process request
  6. Return data

Understanding Rate Limiting

Why rate limit?

Without rate limiting, someone could:

• Overload your server with thousands of requests

• Cost you money (if you pay per request)

• Abuse your API

• Create denial of service

Our rate limit: 100 requests per hour per API key

How it works:

Every time a request comes in, we:

1. Count how many requests this API key made in the last hour

2. If it’s 100 or more → reject with 429 error

3. If under 100 → allow and log the request

Example:

10:00 AM - Request 1 ✅
10:15 AM - Request 2 ✅
...
10:50 AM - Request 100 ✅
10:55 AM - Request 101 ❌ (Rate limit exceeded, retry after 11:00 AM)
11:01 AM - Request 102 ✅ (Request 1 is now older than 1 hour)

Understanding Middleware & Decorators

What is middleware?

Code that runs before your endpoint function. Perfect for:

• Authentication

• Rate limiting

• Logging

• Request validation

Without middleware (repetitive):

@app.route('/weather/<city>')
def get_weather(city):
    # Check API key
    api_key = request.headers.get('X-API-Key')
    if not api_key:
        return jsonify({'error': 'No key'}), 401
    
    # Validate key
    if not is_valid_key(api_key):
        return jsonify({'error': 'Invalid key'}), 401
    
    # Check rate limit
    if is_rate_limited(api_key):
        return jsonify({'error': 'Rate limit'}), 429
    
    # Finally, actual logic
    return jsonify(weather_data)

With middleware (clean):

@app.route('/weather/<city>')
@require_api_key  # ← This handles all authentication!
def get_weather(city):
    # Just the actual logic!
    return jsonify(weather_data)

The @require_api_key decorator does all the work:

• Checks for API key header

• Validates the key

• Checks rate limit

• Logs the request

• Only calls your function if everything is valid

Security Best Practices

1. Never share your API key publicly

# ❌ BAD - Don't commit this to GitHub
API_KEY = "wapi_a8f3c2e1b9d4f6a7c3e8b2d9f1a4c6e3"

# ✅ GOOD - Use environment variables
import os
API_KEY = os.getenv('WEATHER_API_KEY')

2. Use HTTPS in production

• API keys in headers are visible on HTTP

• Always use HTTPS to encrypt traffic

• Free with services like Heroku, Railway

3. Store keys securely

• Add api_keys.json to .gitignore

• Never commit keys to version control

• Use environment variables for sensitive data

4. Implement rate limiting

• Prevents abuse

• Protects your infrastructure

• Fair usage for all users

5. Monitor usage

• Track which keys are used most

• Detect suspicious patterns

• Revoke abusive keys

What You’ve Accomplished This Week

🎉 Congratulations! You’ve built a complete, production-ready API and learned:

• Day 1: API fundamentals, Flask routes, GET requests, JSON responses

• Day 2: POST requests, data validation, JSON file storage

• Day 3: API key authentication, rate limiting, usage tracking

You now have a professional Weather API that: ✅ Handles GET and POST requests
✅ Validates all incoming data
✅ Stores data persistently
✅ Requires authentication
✅ Tracks usage per API key
✅ Implements rate limiting
✅ Returns proper HTTP status codes
✅ Production-ready security

This is how real APIs work!

You’ve learned the fundamentals that power every web service on the internet! 🚀

View Code Evolution

Compare today’s solution with earlier versions and see how we evolved from a basic API to a production-ready authenticated service.

Read more

This week, we build a real-world Weather Data API from scratch using Flask, teaching you how APIs work by building one yourself.

• Day 1: Basic Weather API with Flask

• Day 2: POST Requests & Data Storage (Today)

• Day 3: API Key Authentication

View All Projects This Week

Today’s Project

Yesterday we built a basic API that retrieves data (GET requests). Today we’re adding POST requests so users can submit their own weather reports, and we’ll store that data in a JSON file!

You’ll learn the difference between GET and POST, how to accept user data, validate it, and persist it to storage!

Project Task

Create an enhanced Weather API that:

• Accepts POST requests to submit weather data

• Validates incoming data (required fields, valid values)

• Stores submitted weather reports in JSON file

• Returns newly submitted data

• Retrieves stored weather reports

• Handles both GET and POST on same endpoint

• Persists data between server restarts

• Provides helpful error messages for invalid data

This project gives you hands-on practice with POST requests, request data handling, JSON file storage, data validation, CRUD operations, and building interactive APIs — essential skills for backend development!

Expected Output

Running the API:

python solution.py

Console Output:

Test GET (retrieve): http://127.0.0.1:5000/weather/newyork

You can send the GET request to the API either by visiting the above URL in your browser:

Or through a Python script such as this one below. In this case the Python script is the app that is consuming your API:

import requests

response = requests.get("http://127.0.0.1:5000/weather/newyork")

print(response.json())

Test POST (submit new weather report):

Similarly, Python programs such as this one can send data to the API. These are known as POST requests:

import requests

response = requests.post(
    "http://127.0.0.1:5000/weather/submit",
    json={
        "city": "San Francisco",
        "temperature": 65,
        "unit": "fahrenheit",
        "conditions": "Foggy",
        "humidity": 75,
        "wind_speed": 10
    }
)

print(response.json())

The data that the Python script sends are received by the API. Then, as the developer of the API you can do whatever you want with the data. So, at this point the two apps are communicating with each other sending and receiving data.

Setup Instructions

Install Required Package:

pip install flask

Same as Day 1 - no new packages needed!

Run the API:

python solution.py

The API creates weather_data.json automatically to store submitted reports.

Understanding GET vs POST

GET = Retrieve data

• Read-only operation

• Parameters in URL (?city=london)

• Browser can do GET requests

• Idempotent (same result every time)

• Example: Getting weather for a city

POST = Submit data

• Sends data to server

• Data in request body (JSON)

• Cannot be done from browser URL bar

• Creates or modifies data

• Example: Submitting a weather report

Visual comparison:

GET Request:
  Client → "Give me weather for London" → Server
  Client ← Temperature: 15°C, Rainy ← Server

POST Request:
  Client → "Here's weather data for Austin" + JSON → Server
  Client ← "Saved! Report ID: austin_123" ← Server

Understanding Request Data in Flask

Accessing POST data:

from flask import request

@app.route('/weather/submit', methods=['POST'])
def submit_weather():
    # Get JSON data from request body
    data = request.get_json()
    
    # Access fields
    city = data.get('city')
    temperature = data.get('temperature')
    
    # Validate
    if not city:
        return jsonify({'error': 'City is required'}), 400
    
    # Process and return
    return jsonify({'message': 'Success', 'data': data})

Key Flask concepts:

# Specify HTTP methods
@app.route('/endpoint', methods=['GET', 'POST'])

# Get JSON from request
data = request.get_json()

# Get specific field with default
city = data.get('city', 'Unknown')

# Return error with status code
return jsonify({'error': 'Invalid data'}), 400

Understanding JSON File Storage

Why JSON files?

• Simple for small projects

• Human-readable

• No database setup needed

• Perfect for learning

Understanding Data Validation

Why validate?

• Prevent bad data from being stored

• Give users helpful error messages

• Ensure data consistency

• Avoid crashes

Validation checks we implement:

1. Required fields - All fields must be present

2. Temperature range - Between -100 and 150

3. Humidity range - Between 0 and 100

4. Wind speed range - Between 0 and 200

5. Valid units - Only ‘celsius’ or ‘fahrenheit’

Validation example:

# Check required fields
required = ['city', 'temperature', 'unit', 'conditions', 'humidity', 'wind_speed']
missing = [field for field in required if field not in data]

if missing:
    return jsonify({
        'error': 'Missing required fields',
        'missing': missing
    }), 400

# Validate temperature
if not -100 <= data['temperature'] <= 150:
    return jsonify({
        'error': 'Invalid temperature',
        'message': 'Temperature must be between -100 and 150'
    }), 400

Coming Tomorrow

Tomorrow we’re adding API key authentication — generate API keys, protect endpoints, implement rate limiting, and make your API production-ready with security!

View Code Evolution

Compare today’s solution with yesterday’s version and see how we added POST requests and data storage.

Read more

This week, we build a real-world Weather Data API from scratch using Flask, teaching you how APIs work by building one yourself.

Why build this? Because APIs are everywhere — every app, website, and service uses them. Instead of just consuming APIs, you’ll learn how to create them. By the end of this week, you’ll have built a production-ready API with authentication!

What you’ll learn: This series teaches you API fundamentals, Flask web framework, HTTP methods (GET/POST), JSON responses, route handling, and API authentication. These skills apply to any web service you’ll ever build.

Why users love this: Build something real! Your API will actually work — you can test it in the browser, use it in other projects, or even deploy it for others to use. This is how Stripe, Twitter, and OpenAI APIs work!

• Day 1: Basic Weather API with Flask (Today)

• Day 2: POST Requests & Data Storage

• Day 3: API Key Authentication

View All Projects This Week

Today’s Project

We’re starting with the foundation: a simple Flask API that returns weather data. You’ll learn what an API is, how to create endpoints, return JSON data, and test your API!

You’ll understand routes, HTTP GET requests, JSON responses, and how to structure an API!

Project Task

Create a basic Weather API that:

• Returns current weather for different cities

• Multiple API endpoints (routes)

• Returns data in JSON format

• Handles multiple cities (New York, London, Tokyo, etc.)

• Provides temperature, conditions, humidity

• Works in the browser

• Can be tested with curl or Postman

• Clean, simple Flask structure

This project gives you hands-on practice with Flask, API endpoints, JSON responses, route parameters, HTTP methods, and building web services — essential skills for backend development!

Expected Output

Running the API:

python solution.py

Console Output:

 * Running on http://127.0.0.1:5000
 * Debug mode: on

Test in browser and go to http://127.0.0.1:5000/

You will see this:

Test endpoint: http://127.0.0.1:5000/weather/newyork

Let’s try London now: http://127.0.0.1:5000/weather/london

Or get all available cities: http://127.0.0.1:5000/weather/all

If the city does not exist, the API gracefully returns a message: http://127.0.0.1:5000/weather/fakecity

Setup Instructions

Install Required Package:

pip install flask

That’s it! Flask is all you need for Day 1.

Run the API:

python solution.py

The API will start on

http://127.0.0.1:5000

Understanding APIs

What is an API?

API = Application Programming Interface

Think of it as a restaurant menu:

• Menu = API documentation (what you can order)

• Order = API request (asking for something)

• Food = API response (getting what you asked for)

How APIs work:

Client (Browser/App) → HTTP Request → Your API (Flask)
                                          ↓
                                    Process Request
                                          ↓
Client ← HTTP Response (JSON) ← Your API

Endpoints = URLs that do different things:

http://127.0.0.1:5000/              → Home (API info)
http://127.0.0.1:5000/weather/tokyo → Get Tokyo weather
http://127.0.0.1:5000/weather/all   → Get all cities

JSON = Data format for APIs:

APIs use JSON (JavaScript Object Notation) because:

• Easy for computers to read

• Easy for humans to read

• Works in any programming language

• Lightweight and fast

HTTP Methods (for now, just GET):

• GET = Retrieve data (”Get me the weather for London”)

• POST = Send data (tomorrow!)

• PUT = Update data

• DELETE = Remove data

Understanding Flask

What is Flask?

Flask is a lightweight Python web framework that makes it easy to build APIs and web apps.

Basic Flask structure:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify({"message": "Hello, World!"})

if __name__ == '__main__':
    app.run(debug=True)

Key concepts:

1. Routes (Endpoints):

@app.route('/weather/tokyo')
def tokyo_weather():
    return jsonify({"city": "Tokyo", "temp": 22})

2. Dynamic routes (Path parameters):

@app.route('/weather/<city>')
def get_weather(city):
    # city is a variable from the URL
    return jsonify({"city": city})

3. Returning JSON:

from flask import jsonify

data = {"city": "London", "temp": 15}
return jsonify(data)

4. Error handling:

return jsonify({"error": "Not found"}), 404

Coming Tomorrow

Tomorrow we’ll add POST requests so users can submit their own weather reports, and we’ll store data in a JSON file. You’ll learn the difference between GET (retrieve) and POST (submit)!

Skeleton and Solution

Below you will find both a downloadable skeleton.py file to help you code the project with comment guides and the downloadable solution.py file containing the correct solution.

Get the code skeleton here:

View Code Skeleton

Get the code solution here:

View Code Solution

This week, we build an AI-powered YouTube video summarizer that extracts transcripts and generates intelligent summaries using LangChain and Google’s Gemini AI.

• Day 1: YouTube Video Summarizer

• Day 2: Timestamped Chapters & Key Insights

• Day 3: YouTube Summarizer Web App (Today)

View All Projects This Week

Today’s Project

Welcome to the finale! We’ve built command-line tools for YouTube summarization. Today we’re creating a beautiful web app that anyone can use — no terminal, no Python knowledge required!

Paste a YouTube URL, click a button, and get instant summaries with chapters, insights, and action items. A production-ready app you can deploy and share!

Project Task

Create a YouTube summarizer web app that:

• Beautiful web interface built with Streamlit

• Simple URL input field

• One-click summarization

• Displays chapters with clickable timestamps

• Shows key insights and quotes

• Lists action items

• Clean, modern design

• Real-time AI processing

• Shareable results

• Deployment ready

This project gives you hands-on practice with Streamlit, web app development, user interface design, real-time processing, and building production-ready AI tools that anyone can use!

Expected Output

Here is how the web app looks like. The user simply pastes the YouTube video URL and get a video summary right away:

Setup Instructions

Install Required Packages:

pip install streamlit youtube-transcript-api langchain-google-genai

Get Your Google API Key:

1. Go to Google AI Studio

2. Click “Create API Key”

3. Copy your key

4. Paste it in the script where it says YOUR_GOOGLE_API_KEY

Run the web app:

streamlit run solution.py

Your browser will automatically open to

http://localhost:8501

Deploy to Streamlit Cloud (Optional):

1. Push your code to GitHub

2. Go to share.streamlit.io

3. Connect your repo

4. Add your Google API key in Secrets:

GOOGLE_API_KEY = "your-key-here"

1. Deploy! Your app is now live and shareable

Understanding Streamlit for This App

Key Streamlit features we use:

import streamlit as st

# Page config
st.set_page_config(page_title="YouTube Summarizer", page_icon="🎥")

# Title
st.title("🎥 YouTube Video Summarizer")

# Text input
url = st.text_input("Enter YouTube URL")

# Button
if st.button("🔍 Summarize Video"):
    # Process video
    
# Status messages
st.success("✅ Video Loaded")
st.info("📺 Generating summary...")

# Expanders for sections
with st.expander("⏱️ CHAPTERS", expanded=True):
    st.markdown(chapters)

# Markdown for formatting
st.markdown("**Bold text**")

Session state for this app:

# Store summary results
if 'summary' not in st.session_state:
    st.session_state.summary = None
    st.session_state.video_id = None

Why Streamlit is perfect for this:

✅ Simple input - Just a text box for URL
✅ One button - “Summarize” triggers everything
✅ Beautiful output - Markdown renders perfectly
✅ Collapsible sections - Expanders for chapters/insights
✅ Fast development - Built in pure Python
✅ Easy deployment - Free Streamlit Cloud hosting

Design Decisions

Clean, focused interface:

• Single input field (YouTube URL)

• One primary action (Summarize button)

• Clear status messages during processing

• Well-organized output sections

User experience:

• Loading indicators during AI processing

• Collapsible sections to reduce scrolling

• Emojis for visual hierarchy

• “Summarize Another Video” button to reset

Output organization:

1. Chapters first (most useful for navigation)

2. Key insights (memorable quotes)

3. Action items (what to do)

4. Summary (overall assessment)

What You’ve Accomplished This Week

🎉 Congratulations! You’ve built a complete YouTube summarization system and learned:

• Day 1: Basic transcript extraction and AI summarization

• Day 2: Timestamped chapters and actionable insights

• Day 3: Production web app with beautiful UI

You now have a production-ready AI application that: ✅ Summarizes any YouTube video instantly
✅ Breaks videos into navigable chapters
✅ Extracts key insights and quotes
✅ Provides actionable takeaways
✅ Beautiful web interface anyone can use
✅ Ready to deploy and share

This is a complete AI content tool — from YouTube URL to structured insights!

View Code Evolution

Compare today’s solution with earlier versions and see how we evolved from command-line tools to a full-featured web application.

Read more

This week, we build an AI-powered YouTube video summarizer that extracts transcripts and generates intelligent summaries using LangChain and Google’s Gemini AI.

• Day 1: YouTube Video Summarizer

• Day 2: Timestamped Chapters & Key Insights (Today)

• Day 3: YouTube Summarizer Web App

View All Projects This Week

Today’s Project

Yesterday we built a basic video summarizer. Today we’re adding timestamped chapters and key insights — break videos into sections with timestamps, extract important quotes, and identify actionable takeaways!

Perfect for long lectures, podcasts, and tutorials where you need to jump to specific sections!

Project Task

Create an enhanced YouTube summarizer that:

• Generates timestamped chapter breakdown

• Extracts key quotes from the video

• Identifies action items and takeaways

• Shows duration for each chapter

• Highlights the most important moments

• Provides structured, scannable output

• Works from command line

This project gives you hands-on practice with timestamp formatting, content segmentation, quote extraction, actionable insight generation, and building tools that make long-form content navigable — essential skills for content analysis tools!

Expected Output

Here is how the program works when we give it this video below:

The program will load the video transcript, send the transcript to the AI model and then provide a breakdown of the video in the terminal including timestamps for each section:

Moreover, it will extract key insights and action items. For example, for the TED talk video we used, it will make a list of practical tasks you can do to implement the ideas discussed in the video:

Setup Instructions

Install Required Packages:

pip install youtube-transcript-api langchain-google-genai

Same packages as Day 1 - no new installations needed!

Run the tool:

python solution.py

Then paste any YouTube video URL such as this one and get chapters, insights, and action items!

Understanding Timestamped Chapters

How we generate chapters:

The AI analyzes the full transcript and identifies natural section breaks based on topic changes. Then it creates timestamps in YouTube’s format: [HH:MM:SS] or [MM:SS].

Our prompt strategy:

prompt = f"""Analyze this YouTube video transcript and provide:

1. CHAPTERS: Break the video into 6-10 logical sections with timestamps
   Format each as: [MM:SS] Chapter Title - Brief description
   
2. KEY INSIGHTS: Extract 3-5 most important quotes from the video
   Include the chapter/timestamp where each quote appears
   
3. ACTION ITEMS: List 3-7 concrete takeaways viewers can implement

Transcript with timestamps:
{transcript_with_times}
"""

Timestamp formatting:

def format_timestamp(seconds):
    hours = int(seconds // 3600)
    minutes = int((seconds % 3600) // 60)
    secs = int(seconds % 60)
    
    if hours > 0:
        return f"[{hours}:{minutes:02d}:{secs:02d}]"
    else:
        return f"[{minutes:02d}:{secs:02d}]"

Why include timestamps in the transcript:

We send the transcript to AI with timestamp markers so it knows when topics are discussed. This allows accurate chapter generation!

Understanding Key Insights vs Action Items

Key Insights = The most important ideas from the video

• Quotes and concepts that are memorable

• Core arguments or findings

• “Aha moments” viewers should remember

Action Items = The concrete steps viewers can take

• Specific things to do/build/implement

• Practical applications of the concepts

• Next steps for viewers

Coming Tomorrow

Tomorrow we’re building a beautiful web app with Streamlit where anyone can paste YouTube URLs, get instant summaries with chapters, and navigate long videos effortlessly!

View Code Evolution

Compare today’s solution with yesterday’s version and see how we added timestamp analysis and structured insights.

Read more

This week, we build an AI-powered YouTube video summarizer that extracts transcripts and generates intelligent summaries using LangChain and Google’s Gemini AI.

Why build this? Because we waste hours watching long YouTube videos. Lectures, tutorials, podcasts, conferences — what if you could get the key points in 30 seconds instead of watching for 2 hours?

What you’ll learn: This series teaches you how to extract YouTube transcripts, process video content with AI, generate structured summaries, and build tools that save people massive amounts of time. These skills apply to any content processing project.

Why users love this: No more scrubbing through long videos looking for that one thing. Paste a YouTube URL, get an instant summary with all the key points. Perfect for students, researchers, and busy professionals!

• Day 1: YouTube Video Summarizer (Today)

• Day 2: Timestamped Chapters & Key Insights

• Day 3: YouTube Summarizer Web App

View All Projects This Week

Today’s Project

We’re starting with the foundation: a command-line tool that takes any YouTube URL, extracts the transcript, and uses Gemini AI to generate a concise, intelligent summary!

You’ll learn how to extract YouTube transcripts programmatically, process long-form content, and use AI to distill hours of video into digestible summaries!

Project Task

Create a YouTube video summarizer that:

• Accepts any YouTube video URL

• Extracts the full video transcript automatically

• Gets video metadata (title, duration, channel)

• Uses LangChain + Gemini to generate summaries

• Creates concise, readable summaries

• Handles videos of any length

• Works from command line

• No API keys needed for YouTube (uses youtube-transcript-api)

This project gives you hands-on practice with YouTube data extraction, transcript processing, AI summarization, content analysis, and building practical time-saving tools — essential skills for modern content automation!

Expected Output

You can run the script with “python solution.py” paste a YouTube video URL there such as this “How to stop thinking” and the program will print out a summary of the video in the terminal as you can see below:

Setup Instructions

Install Required Packages:

pip install youtube-transcript-api langchain-google-genai

Get Your Google API Key:

1. Go to Google AI Studio

2. Click “Create API Key”

3. Copy your key

4. Paste it in the script where it says YOUR_GOOGLE_API_KEY

That’s it! The YouTube transcript API is completely free and requires no API key.

What each package does:

• youtube-transcript-api - Extracts video transcripts from YouTube (FREE!)

• langchain-google-genai - Google Gemini integration for summaries

Run the tool:

python solution.py

Then paste any YouTube URL and get an instant summary!

Understanding YouTube Transcript API

How it works:

The youtube-transcript-api library fetches the official YouTube transcript/captions. It doesn’t use any API keys — it just accesses the same captions you see when you click “CC” on a video.

from youtube_transcript_api import YouTubeTranscriptApi

# Extract video ID from URL
video_id = "dQw4w9WgXcQ"

# Get transcript
transcript = YouTubeTranscriptApi.get_transcript(video_id)

# Transcript format:
# [
#   {'text': 'Hello everyone', 'start': 0.0, 'duration': 2.5},
#   {'text': 'Welcome to my video', 'start': 2.5, 'duration': 3.0},
#   ...
# ]

Key features:

✅ Free - No API key required
✅ Fast - Instant transcript retrieval
✅ Accurate - Uses official YouTube captions
✅ Multiple languages - Supports auto-translated captions
✅ No rate limits - Reasonable usage is unlimited

Extracting video ID from URL:

from urllib.parse import urlparse, parse_qs

def get_video_id(url):
    # Handle different YouTube URL formats
    # youtube.com/watch?v=VIDEO_ID
    # youtu.be/VIDEO_ID
    # youtube.com/embed/VIDEO_ID
    
    if 'youtu.be' in url:
        return url.split('/')[-1].split('?')[0]
    elif 'youtube.com' in url:
        parsed = urlparse(url)
        return parse_qs(parsed.query).get('v', [None])[0]

Limitations:

• Only works if the video has captions (auto-generated or manual)

• Can’t access age-restricted or private videos

• Very long videos (5+ hours) may be slow to process

Understanding the Summarization Approach

Our strategy:

YouTube URL → Extract video ID → Get transcript → Format as text
                                                        ↓
                                            Send to Gemini with prompt
                                                        ↓
                                Generate structured summary

Smart prompting for good summaries:

prompt = f"""Summarize this YouTube video transcript in a clear, 
structured format.

Video Title: {title}
Duration: {duration}

Transcript:
{transcript_text}

Provide:
1. A concise 2-3 paragraph summary
2. Key topics covered (bullet points)
3. Main takeaways (numbered list)
4. Whether the video is worth watching and for whom

Keep it concise but informative."""

Why this approach works:

Context first - Title and duration help AI understand the video
Structured output - Specific sections make it scannable
Actionable - “Worth watching?” helps users decide
Concise - Summaries are quick to read

Coming Tomorrow

Tomorrow we’ll add timestamped chapters and key insights — break the video into sections with timestamps, extract the most important quotes, and identify action items you can implement immediately!

Skeleton and Solution

Below you will find both a downloadable skeleton.py file to help you code the project with comment guides and the downloadable solution.py file containing the correct solution.

Get the code skeleton here:

View Code Skeleton

Get the code solution here:

View Code Solution

This week, we build a smart PDF analyzer powered by LangChain and Google’s Gemini AI that lets you upload PDFs and ask questions about them.

• Day 1: PDF Question Answering

• Day 2: Multi-PDF Comparison

• Day 3: PDF Analyzer Web App (Today)

View All Projects This Week

Today’s Project

Welcome to the finale! We’ve built command-line tools for single and multiple PDF analysis. Today we’re creating a beautiful web app that anyone can use — no terminal, no Python knowledge required!

Upload PDFs through your browser, ask questions in a chat interface, and get instant AI-powered answers. A production-ready app you can deploy and share!

Project Task

Create a PDF analyzer web app that:

• Beautiful web interface built with Streamlit

• Drag-and-drop PDF upload

• Upload single or multiple PDFs

• Clean chat interface for asking questions

• Displays conversation history

• Shows which PDFs are loaded

• Real-time AI responses

• No command-line needed

• One-click deployment ready

This project gives you hands-on practice with Streamlit, web app development, file uploads, session state management, chat interfaces, and building production-ready AI applications — essential skills for deploying AI tools!

Expected Output

Running the app:

streamlit run solution.py

Browser opens automatically showing:

The user can click the “Browser files” button to upload PDF files. Then, they can chat with their PDFs:

As you can see above, we ask a question that needs statistical analysis performed on the data contained inside the PDFs. And the AI gives a very good answer pointing out students with the highest grade, highlighting the document where that student data is located.

If you want to try this, you can use the same PDFs that I used:

Report

7.95KB ∙ PDF file

Download

Download

Report2

8.06KB ∙ PDF file

Download

Download

Setup Instructions

Install Required Packages:

pip install streamlit langchain-google-genai pypdf

Get Your Google API Key:

1. Go to Google AI Studio

2. Click “Create API Key”

3. Copy your key

4. Paste it in the script where it says YOUR_GOOGLE_API_KEY

Run the web app:

streamlit run solution.py

Your browser will automatically open to

http://localhost:8501

Deploy to Streamlit Cloud (Optional):

1. Push your code to GitHub

2. Go to share.streamlit.io

3. Connect your repo

4. Add your Google API key in Secrets

5. Deploy! Your app is now live and shareable

Understanding Streamlit

What is Streamlit?

Streamlit is a Python framework for building web apps with zero HTML/CSS/JavaScript. Perfect for data scientists and AI developers!

Key Streamlit concepts:

import streamlit as st

# Title
st.title("My App")

# File uploader
uploaded_files = st.file_uploader("Upload PDFs", type="pdf", accept_multiple_files=True)

# Chat messages
with st.chat_message("user"):
    st.write("Question here")

with st.chat_message("assistant"):
    st.write("Answer here")

# Text input
question = st.chat_input("Ask a question")

# Session state (persists data between reruns)
if 'messages' not in st.session_state:
    st.session_state.messages = []

How our app works:

User uploads PDFs → Extract text → Store in session_state
                                            ↓
User asks question → Add to messages → Send to Gemini → Display answer
                                            ↓
                                   Add to session_state
                                            ↓
                                    Show conversation history

Session state management:

Streamlit reruns your entire script on every interaction. Session state persists data:

# Initialize
if 'pdf_content' not in st.session_state:
    st.session_state.pdf_content = ""
    st.session_state.messages = []
    st.session_state.pdf_names = []

# Store PDFs
st.session_state.pdf_content = combined_text
st.session_state.pdf_names = filenames

# Messages persist across reruns
st.session_state.messages.append({"role": "user", "content": question})
st.session_state.messages.append({"role": "assistant", "content": answer})

Why Streamlit for AI apps?

✅ Fast development - Build UIs in pure Python
✅ No frontend skills needed - No HTML/CSS/JS
✅ Perfect for AI/ML - Built-in support for chat, file uploads, charts
✅ Free deployment - Streamlit Cloud hosting
✅ Auto-reload - See changes instantly
✅ Beautiful by default - Professional-looking UIs

What You’ve Accomplished This Week

🎉 Congratulations! You’ve built a complete PDF analysis system and learned:

• Day 1: Single PDF Q&A with LangChain + Gemini

• Day 2: Multi-document comparison and analysis

• Day 3: Production web app with Streamlit

You now have a production-ready AI application that: ✅ Analyzes single or multiple PDFs
✅ Answers questions with AI-powered accuracy
✅ Compares and contrasts multiple documents
✅ Beautiful web interface anyone can use
✅ Maintains conversation history
✅ Ready to deploy and share

This is a complete AI document assistant — from PDF upload to intelligent answers!

View Code Evolution

Compare today’s solution with earlier versions and see how we evolved from command-line tools to a full-featured web application.

Read more

This week, we build a smart PDF analyzer powered by LangChain and Google’s Gemini AI that lets you upload PDFs and ask questions about them.

• Day 1: PDF Question Answering

• Day 2: Multi-PDF Comparison (Today)

• Day 3: PDF Analyzer Web App

View All Projects This Week

Today’s Project

Yesterday we built a tool to ask questions about a single PDF. Today we’re expanding to multiple PDFs — upload several documents and ask comparative questions across all of them!

Compare resumes, analyze multiple research papers, find differences in contracts, or synthesize information from multiple sources!

Project Task

Create a multi-PDF comparison tool that:

• Loads multiple PDF files from a directory

• Extracts text from all documents

• Creates context with all PDFs combined

• Answers questions across all documents

• Compares and contrasts information

• Identifies which document contains specific information

• Maintains conversation history

• Works entirely from command line

This project gives you hands-on practice with batch file processing, multi-document analysis, comparative AI reasoning, and building practical document comparison tools — essential skills for real-world AI applications!

Expected Output

When the user runs the program, they are asked to enter the directory where the PDF files are located (e.g., documents):

In the next step, the user asks a question about the information contained in the PDF files. In our example, we have some university student data in the PDFs and some students are in both PDFs so below we ask the program to give us the student names that are in both documents:

As you can see the program is aware of the PDF file names and gives us the list of shared student names in both documents, and also highlighting some potential issues with the data integrity in the documents which is great information to have.

Here is the PDF files we used for this example:

Report

7.95KB ∙ PDF file

Download

Download

Report2

8.06KB ∙ PDF file

Download

Download

Setup Instructions

Install Required Packages:

pip install langchain-google-genai pypdf

Get Your Google API Key:

1. Go to Google AI Studio

2. Click “Create API Key”

3. Copy your key

4. Paste it in the script where it says YOUR_GOOGLE_API_KEY

Prepare Your PDFs:

Create a directory with multiple PDFs:

./documents/
├── report.pdf
├── report2.pdf

Run the tool:

python solution.py

Enter the directory path and start comparing!

Understanding Multi-Document Analysis

How it works:

Directory → Load all PDFs → Extract text from each → Combine into context
                                                              ↓
                                                    Single system prompt with all docs
                                                              ↓
Your question → "Which document mentions X?" → AI compares all documents → Answer

Key technique: Document labeling

context = ""
for pdf_file in pdf_files:
    content = extract_text(pdf_file)
    context += f"\n\n=== {pdf_file.name} ===\n{content}\n"

This labels each document so the AI knows which content comes from which file!

Multi-document capabilities:

Comparison - “Which resume is stronger?”
Contrast - “What are the differences between these papers?”
Synthesis - “What do all these contracts have in common?”
Attribution - “Which document mentions the refund policy?”
Ranking - “Order these candidates by experience level”

Use cases:

• HR: Compare job applicant resumes

• Research: Analyze multiple papers on the same topic

• Legal: Compare contract versions or terms

• Business: Analyze competitor reports

• Academic: Compare different textbook chapters

Coming Tomorrow

Tomorrow we’re building a web app with Flask/Streamlit that lets anyone upload PDFs through a browser, ask questions, and get instant answers — no command line needed!

View Code Evolution

Compare today’s solution with earlier versions and see how we evolved from single-PDF analysis to multi-document comparison:

Read more