Hands-on lab — Day 24: JSON and Data Serialization

#!/usr/bin/env bash
# Day 024 lab — completed reference: work with JSON using only python3.
#
# Demonstrates the four skills the starter asks you to practise:
#   1. validate a JSON file            (python3 -m json.tool)
#   2. extract a nested field          (python3 one-liner; jq equivalent shown)
#   3. pretty-print a JSON file        (python3 -m json.tool)
#   4. show a broken file being rejected, with its real error
#
# Everything runs offline. Run from the lab directory:
#   bash examples/json_tools.sh
set -euo pipefail

good="examples/samples/config.json"
broken="examples/samples/broken.json"

echo "=== 1. Validate the good file ==="
# `python3 -m json.tool` parses its input and reprints it; it fails loudly
# (non-zero exit) if the input is not valid JSON.
if python3 -m json.tool "${good}" > /dev/null; then
  echo "OK: ${good} is valid JSON"
else
  echo "UNEXPECTED: ${good} failed to parse" >&2
  exit 1
fi
echo

echo "=== 2. Extract a nested field (coordinates.lat) ==="
# Python one-liner: load the file, walk into coordinates, print lat.
python3 -c "import json; print(json.load(open('${good}'))['coordinates']['lat'])"
# jq equivalent (if you have jq installed):
#   jq '.coordinates.lat' examples/samples/config.json
echo

echo "=== 3. Extract the first sensor (sensors[0]) and count top-level keys ==="
python3 -c "import json; d=json.load(open('${good}')); print(d['sensors'][0]); print(len(d), 'top-level keys')"
# jq equivalent:
#   jq '.sensors[0]' examples/samples/config.json
#   jq 'keys | length' examples/samples/config.json
echo

echo "=== 4. Pretty-print the good file ==="
python3 -m json.tool "${good}"
echo

echo "=== 5. The broken file is rejected ==="
# We EXPECT this to fail. Capture the error and show it, then continue.
if python3 -m json.tool "${broken}" > /dev/null 2> /tmp/day024_err.txt; then
  echo "UNEXPECTED: ${broken} parsed but should be invalid" >&2
  exit 1
else
  echo "As expected, ${broken} is invalid JSON. Parser said:"
  sed 's/^/    /' /tmp/day024_err.txt
  rm -f /tmp/day024_err.txt
fi
echo
echo "Done. The good file round-trips; the broken file (a trailing comma) is refused."

{
  "station": "Nimbus-7",
  "active": true,
  "sensors": ["temperature", "humidity", "pressure"],
}

{
  "station": "Nimbus-7",
  "active": true,
  "elevation_m": 512,
  "coordinates": {
    "lat": 26.9124,
    "lon": 75.7873
  },
  "sensors": ["temperature", "humidity", "pressure"],
  "calibration": {
    "temperature": { "offset": -0.4, "unit": "celsius" },
    "last_checked": "2026-07-01"
  },
  "notes": null
}

lesson_id: D024
day: 24
kind: data-processing
languages: [bash]
setup_commands:
  - cd labs/sections/computing-foundations/day-024-json-and-data-serialization
run_commands:
  - bash examples/json_tools.sh
  - bash starter/json_tools.sh
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/json_tools.sh  # optional: reset your work'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-12'
executed_on: 'macOS (Apple Silicon), Python 3.14.0, bash tests/run_tests.sh → 7 checks, 0 failures'

# Dependencies — Day 024 lab

**Only `python3`, which is preinstalled on macOS and every mainstream Linux
distribution.** This lab is deliberately offline and dependency-light:

- `python3` (3.x) — provides `python3 -m json.tool` (validate and
  pretty-print) and the `json` module used by the one-line extractors. No
  third-party packages are installed.
- `bash` (3.2 or newer) — runs the lab scripts. Preinstalled on macOS and
  Linux.

## Optional

- `jq` — a dedicated command-line JSON processor. The lab's scripts show the
  `jq` equivalent of each `python3` step as a comment, so you can compare the
  two styles, but **every required step uses `python3` only**. Install `jq`
  from your package manager if you want to try the commented commands
  (`brew install jq` on macOS, `apt install jq` on Debian/Ubuntu).

## Platform notes

- **macOS / Linux:** nothing to install.
- **Windows:** run the scripts inside WSL (Windows Subsystem for Linux) so
  `bash` and `python3` behave as documented, or install Python 3 for Windows
  and run the individual `python3` commands from the lesson by hand.
- If `python3` is not found but `python` is, and `python --version` reports
  3.x, substitute `python` for `python3` throughout.

#!/usr/bin/env bash
# Day 024 lab — YOUR working file. Complete the four exercises below.
#
# The completed reference version is in examples/json_tools.sh — try each
# exercise yourself first, then compare. Everything runs offline with
# python3 (preinstalled on macOS and Linux). Run from the lab directory:
#   bash starter/json_tools.sh
#
# Each exercise names the exact command to use in its comment. The commands
# below are already filled in so the script runs; work through them one at a
# time, changing the keys and files to explore, and check your understanding
# against examples/json_tools.sh.
set -euo pipefail

good="examples/samples/config.json"
broken="examples/samples/broken.json"

echo "=== Exercise 1: validate the good file ==="
# Use: python3 -m json.tool "${good}"
# It reprints the file if valid and fails with a non-zero exit if not.
# --- your command below ---
python3 -m json.tool "${good}"
echo

echo "=== Exercise 2: extract a nested field (coordinates.lat) ==="
# Use a python3 one-liner that loads the file and prints coordinates -> lat.
# Template (fill in the two keys):
#   python3 -c "import json; print(json.load(open('${good}'))['coordinates']['lat'])"
# jq equivalent (optional): jq '.coordinates.lat' examples/samples/config.json
# --- your command below ---
python3 -c "import json; print(json.load(open('${good}'))['coordinates']['lat'])"
echo

echo "=== Exercise 3: pretty-print the good file ==="
# json.tool already pretty-prints. Print it indented to the screen.
# Use: python3 -m json.tool "${good}"
# --- your command below ---
python3 -m json.tool "${good}"
echo

echo "=== Exercise 4: spot the error in the broken file ==="
# Validate the BROKEN file. It SHOULD fail — read the error it prints.
# Use: python3 -m json.tool "${broken}"
# (We wrap it so the script does not stop on the expected failure.)
# --- your command below ---
if python3 -m json.tool "${broken}" > /dev/null 2>&1; then
  echo "Hmm — broken.json parsed, but it should be invalid. Check the file."
else
  echo "Correct: broken.json is invalid. Full error message:"
  python3 -m json.tool "${broken}" || true
fi
echo
echo "Now record your findings in starter/json-worksheet.md."

# JSON worksheet — Day 024

Fill this in from your own runs of `starter/json_tools.sh` and the commands
in the lesson's hands-on section. Keep it — Week 4's project (a weather
command-line dashboard) parses live JSON and builds on this groundwork.

## The sample file (`examples/samples/config.json`)

| Question | Your answer | Command you used |
| --- | --- | --- |
| How many top-level keys does it have? |  |  |
| One nested value, and the path to it |  |  |
| What value type is `active`? |  | (read it — no command needed) |
| What value type is `sensors`? |  |  |
| What value type is `notes`? |  |  |

Hint for the key count: `python3 -c "import json; print(len(json.load(open('examples/samples/config.json'))))"`

Hint for a nested value: `python3 -c "import json; print(json.load(open('examples/samples/config.json'))['coordinates']['lat'])"`

## The broken file (`examples/samples/broken.json`)

Run `python3 -m json.tool examples/samples/broken.json` and record the exact
error message it prints:

```text
(paste the error line here)
```

**Which single character makes the document invalid?**

(one sentence)

**Why does that one character make the whole document invalid?**

(two or three sentences, in your own words)

## The six JSON value types

List all six value types JSON allows, and next to each write which key in
`config.json` is an example of it (some types appear more than once).

1. object —
2. array —
3. string —
4. number —
5. boolean —
6. null —

#!/usr/bin/env bash
# Tests for the Day 024 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Verifies real behavior with no network:
#   - the valid sample parses cleanly (exit 0)
#   - the broken sample fails to parse (non-zero exit)
#   - field extraction returns the known value (coordinates.lat == 26.9124)
#   - the sample has the expected number of top-level keys (7)
#   - the completed example script runs end to end
set -u

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "${lab_dir}"
good="examples/samples/config.json"
broken="examples/samples/broken.json"
failures=0
checks=0

check() {
  local label="$1" ok="$2"
  checks=$((checks + 1))
  if [ "${ok}" = "yes" ]; then
    echo "  ok: ${label}"
  else
    echo "  FAIL: ${label}"
    failures=$((failures + 1))
  fi
}

# python3 must be available (the whole lab depends on it).
if command -v python3 > /dev/null 2>&1; then
  check "python3 is available" "yes"
else
  check "python3 is available" "no"
  echo
  echo "${checks} checks, ${failures} failure(s)."
  exit 1
fi

# 1. Valid sample parses (exit 0).
if python3 -m json.tool "${good}" > /dev/null 2>&1; then
  check "valid sample parses cleanly" "yes"
else
  check "valid sample parses cleanly" "no"
fi

# 2. Broken sample fails to parse (non-zero exit).
if python3 -m json.tool "${broken}" > /dev/null 2>&1; then
  check "broken sample is rejected" "no"
else
  check "broken sample is rejected" "yes"
fi

# 3. Field extraction returns the known nested value.
lat="$(python3 -c "import json; print(json.load(open('${good}'))['coordinates']['lat'])" 2>/dev/null)"
if [ "${lat}" = "26.9124" ]; then
  check "coordinates.lat extracts to 26.9124" "yes"
else
  check "coordinates.lat extracts to 26.9124 (got '${lat}')" "no"
fi

# 4. Known top-level key count.
keys="$(python3 -c "import json; print(len(json.load(open('${good}'))))" 2>/dev/null)"
if [ "${keys}" = "7" ]; then
  check "sample has 7 top-level keys" "yes"
else
  check "sample has 7 top-level keys (got '${keys}')" "no"
fi

# 5. Known first array element.
first="$(python3 -c "import json; print(json.load(open('${good}'))['sensors'][0])" 2>/dev/null)"
if [ "${first}" = "temperature" ]; then
  check "sensors[0] extracts to 'temperature'" "yes"
else
  check "sensors[0] extracts to 'temperature' (got '${first}')" "no"
fi

# 6. The completed example script runs end to end.
if bash examples/json_tools.sh > /dev/null 2>&1; then
  check "examples/json_tools.sh runs successfully" "yes"
else
  check "examples/json_tools.sh runs successfully" "no"
fi

echo
echo "${checks} checks, ${failures} failure(s)."
[ "${failures}" -eq 0 ]