Hands-on lab — Day 50: Conditionals and Boolean Logic

#!/usr/bin/env python3
"""Decision engine: classify a model prediction into ACCEPT / REVIEW / REJECT.

This is a complete, small, real program that shows every idea from the Day 50
lesson working together: comparison operators, the logical `and` with
short-circuit evaluation, an `if`/`elif`/`else`-style ladder, a guard clause,
a chained comparison for range validation, and a (nested) conditional
expression. It reads its input from the command line, validates it, does one
useful job, prints clear output, and fails gracefully on bad input.

Usage:
    python3 triage.py <score> <status>

<score>  is the model's confidence, a number from 0.0 to 1.0.
<status> is whether an upstream check passed: verified or unverified.

Examples:
    python3 triage.py 0.95 verified     ->  AUTO_ACCEPT
    python3 triage.py 0.95 unverified   ->  REVIEW
    python3 triage.py 0.30 verified     ->  REJECT
"""
import sys

VALID_STATUSES = ("verified", "unverified")


def confidence_band(score):
    """Return 'high', 'medium', or 'low' for a score in 0.0-1.0.

    A three-way choice written as a nested conditional (ternary) expression.
    """
    return "high" if score >= 0.9 else ("medium" if score >= 0.5 else "low")


def classify(score, verified):
    """Return the routing decision for a prediction.

    Uses a guard clause to reject low confidence first, then the logical
    `and` (which short-circuits) to auto-accept only what is both confident
    and verified, and falls through to REVIEW for everything else.
    """
    if score < 0.5:                       # guard clause: turn away low confidence
        return "REJECT"
    if score >= 0.9 and verified:         # confident AND checked: safe to accept
        return "AUTO_ACCEPT"
    return "REVIEW"                        # medium confidence, or high-but-unverified


def parse_args(args):
    """Validate raw [score, status] arguments and return (float, bool).

    Raises ValueError with a human-readable message on any bad input:
    wrong argument count, a non-numeric score, an unknown status, or a
    score outside the 0.0-1.0 range.
    """
    if len(args) != 2:
        raise ValueError("expected 2 arguments: <score> <status> (e.g. 0.95 verified)")
    score_text, status_text = args
    try:
        score = float(score_text)
    except ValueError:
        raise ValueError(f"'{score_text}' is not a number")
    status = status_text.strip().lower()
    if status not in VALID_STATUSES:
        raise ValueError(f"status must be verified or unverified, not '{status_text}'")
    if not 0.0 <= score <= 1.0:           # chained comparison: range check
        raise ValueError(f"score {score} is out of range (expected 0.0 to 1.0)")
    verified = status == "verified"
    return score, verified


def format_result(score, verified, category, band):
    """Return the one-line, human-readable decision string."""
    return f"score={score:.2f} verified={str(verified):<5} -> {category} (confidence: {band})"


def main(argv):
    """Program entry point. Returns an exit code: 0 on success, 2 on bad input."""
    try:
        score, verified = parse_args(argv[1:])
    except ValueError as err:
        print(f"error: {err}", file=sys.stderr)
        print("usage: python3 triage.py <score> <status>   "
              "(score 0.0-1.0, status verified|unverified)", file=sys.stderr)
        return 2
    category = classify(score, verified)
    band = confidence_band(score)
    print(format_result(score, verified, category, band))
    return 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))

lesson_id: D050
day: 50
kind: python-program
languages: [python]
setup_commands:
  - cd labs/sections/programming-with-python/day-050-conditionals-and-boolean-logic
  - python3 --version
run_commands:
  - python3 examples/triage.py 0.95 verified
  - python3 examples/triage.py 0.95 unverified
  - python3 starter/triage.py 0.70 verified
test_commands:
  - bash tests/run_tests.sh
cleanup_commands:
  - 'git checkout -- starter/triage.py  # optional: reset your work'
requires_network: false
requires_api_key: false
estimated_minutes: 30
last_executed: '2026-07-13'
executed_on: 'macOS (Apple Silicon), Python 3.14.0, bash tests/run_tests.sh → 14 checks, 0 failure(s), exit 0'

# Dependencies — Day 050 lab

**Python 3 only. No third-party packages.**

- `python3` (3.8 or newer; tested on 3.14). Preinstalled on most Linux
  distributions and installable on macOS; you set this up on Day 43.
- `bash` for the test runner (preinstalled on macOS and Linux).
- Only the Python standard library is used — specifically the `sys` module,
  which ships with Python. There is deliberately no `requirements.txt`: a
  decision engine this small should run on a plain Python install with nothing
  to install first.

Check your Python is present and new enough:

```bash
python3 --version
```

If that prints `Python 3.8` or higher, you are ready. Windows users: run the
commands inside WSL, or use `python` in place of `python3` if that is how Python
is exposed on your system.

The lesson mentions optional free tools you may install later to keep boolean
logic honest — `ruff`, `pylint`, `flake8`, `mypy`, and `pytest` — but none of
them are required to build or test this lab.

# Decision-engine design worksheet

Design your program *before* you code it. Fill in every section for a decision
engine of your own choosing (spam-or-not filter, loan pre-check, support-ticket
priority router, temperature alert — anything with clear rules). Then implement
it with the same shape as `triage.py`.

## 1. The job (one sentence)

> Example: Route a model prediction to AUTO_ACCEPT, REVIEW, or REJECT based on
> its confidence score and whether an upstream check passed.

_Your job:_

## 2. Inputs (what arrives, and from where)

List each input, its type, and where it comes from (command-line argument,
file, etc.).

| Input | Type | Source | Example |
| ----- | ---- | ------ | ------- |
| _e.g. score_ | _float 0.0-1.0_ | _sys.argv[1]_ | _0.95_ |
|  |  |  |  |

## 3. Rules (each as a boolean condition)

Write every rule as a condition, using `and` / `or` / `not`. Mark which one is
a **guard clause** (checked first, exits early) and note any **chained
comparison** (e.g. `0.0 <= score <= 1.0`).

- Guard clause: _________________________________________________
- Rule 1: _______________________________________________________
- Rule 2: _______________________________________________________
- Rule 3: _______________________________________________________

## 4. Outcomes (categories, and which rule leads to each)

| Outcome | Reached when | Exit code |
| ------- | ------------ | --------- |
| _e.g. AUTO_ACCEPT_ | _score >= 0.9 and verified_ | _0_ |
|  |  |  |

## 5. Edge cases you will reject

List at least three inputs your program must refuse, and the message it prints.

1.
2.
3.

## 6. Where a ternary fits

Name one place a conditional (ternary) expression makes a clean two-way (or
nested three-way) value choice.

>

#!/usr/bin/env python3
"""Decision engine — YOUR working file.

Build this program one exercise at a time. Each numbered exercise below names
exactly what to write, using the boolean logic from the Day 50 lesson. The
finished reference is in examples/triage.py — try each exercise yourself
before peeking.

When you have completed all five exercises, this file should behave just like
the reference:

    python3 starter/triage.py 0.95 verified   ->  ... AUTO_ACCEPT (confidence: high)
    python3 starter/triage.py 1.5 verified    ->  error (exit code 2)

Then run:  bash tests/run_tests.sh
"""
import sys

VALID_STATUSES = ("verified", "unverified")


def confidence_band(score):
    """Return 'high', 'medium', or 'low' for a score in 0.0-1.0."""
    # Exercise 1: WRITE A NESTED TERNARY (conditional expression).
    # Return "high" when score >= 0.9, "medium" when score >= 0.5,
    # otherwise "low". Do it in one line:
    #   return "high" if score >= 0.9 else ("medium" if score >= 0.5 else "low")
    # Verify by hand: confidence_band(0.5) must be "medium".
    raise NotImplementedError("Exercise 1: implement confidence_band")


def classify(score, verified):
    """Return the routing decision: REJECT, AUTO_ACCEPT, or REVIEW."""
    # Exercise 2: WRITE THE CLASSIFICATION LADDER.
    # 1. Guard clause: if score < 0.5, return "REJECT" immediately.
    # 2. If score >= 0.9 AND verified, return "AUTO_ACCEPT"
    #    (note the logical `and` short-circuits: verified is only checked
    #     when score >= 0.9 is already True).
    # 3. Otherwise return "REVIEW".
    raise NotImplementedError("Exercise 2: implement classify")


def parse_args(args):
    """Validate raw [score, status] arguments and return (float, bool)."""
    # Exercise 3: VALIDATE INPUT (guard the boundary).
    # 1. If len(args) != 2, raise ValueError with a clear message.
    # 2. Convert args[0] to float inside try/except; on failure raise
    #    ValueError(f"'{args[0]}' is not a number").
    # 3. Normalise args[1] with .strip().lower(); if it is not in
    #    VALID_STATUSES, raise ValueError naming the allowed statuses.
    # 4. Use a CHAINED COMPARISON to reject an out-of-range score:
    #    if not 0.0 <= score <= 1.0: raise ValueError(...).
    # 5. Return (score, status == "verified").
    raise NotImplementedError("Exercise 3: implement parse_args")


def format_result(score, verified, category, band):
    """Return the one-line, human-readable decision string."""
    # Exercise 4: FORMAT OUTPUT.
    # Return an f-string like:
    #   score=0.95 verified=True  -> AUTO_ACCEPT (confidence: high)
    # Show the score to two decimals (:.2f) and left-pad the verified flag
    # to width 5 so True and False line up: {str(verified):<5}.
    raise NotImplementedError("Exercise 4: implement format_result")


def main(argv):
    """Program entry point. Returns an exit code: 0 on success, 2 on bad input."""
    try:
        score, verified = parse_args(argv[1:])
    except ValueError as err:
        print(f"error: {err}", file=sys.stderr)
        print("usage: python3 triage.py <score> <status>   "
              "(score 0.0-1.0, status verified|unverified)", file=sys.stderr)
        return 2
    category = classify(score, verified)
    band = confidence_band(score)
    print(format_result(score, verified, category, band))
    return 0


# Exercise 5: ADD THE MAIN GUARD.
# Below this comment, add the guard so the program runs only when this file
# is executed directly (not when it is imported):
#
#     if __name__ == "__main__":
#         sys.exit(main(sys.argv))

#!/usr/bin/env bash
# Tests for the Day 050 lab. Run from the lab directory:
#   bash tests/run_tests.sh
#
# Exercises the complete reference program (examples/triage.py) on known good
# and bad inputs, checking both the printed output and the process exit code,
# then imports two functions and checks their return values (the payoff of the
# main guard). Finally it checks the learner's starter: structurally while the
# exercises are unfinished, and to the same strict standard once complete.
# No network, non-interactive. Exits 0 only if every check passes.
set -u

# Keep the working tree clean: do not let imported modules write __pycache__.
export PYTHONDONTWRITEBYTECODE=1

lab_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

# Bytecode left by an EARLIER command is not this run's litter. The README
# documents `pytest starter -q`, and running it writes .pyc files that would
# then fail the cleanliness check at the end of this script -- failing the
# reader for following the instructions. Clearing them here makes that final
# check measure what it claims to: what THIS run left behind. `.venv` is
# untouched, because the packages' own bytecode is theirs, not ours.
find "${lab_dir}" -name '.venv' -prune -o -type d -name '__pycache__' -exec rm -rf {} + 2>/dev/null || true
find "${lab_dir}" -name '.venv' -prune -o -type d -name '.pytest_cache' -exec rm -rf {} + 2>/dev/null || true

ref="${lab_dir}/examples/triage.py"
starter="${lab_dir}/starter/triage.py"
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
}

# check_run <label> <script> <expect_exit> <needle> <arg...>
# Runs the program, checks its exit code equals expect_exit and that its
# combined output contains needle.
check_run() {
  local label="$1" script="$2" expect_exit="$3" needle="$4"
  shift 4
  local out code
  out="$(python3 "${script}" "$@" 2>&1)"
  code=$?
  if [ "${code}" -eq "${expect_exit}" ] && printf '%s' "${out}" | grep -qF "${needle}"; then
    check "${label}" "yes"
  else
    check "${label}" "no"
    echo "    (exit ${code}, expected ${expect_exit}; output: ${out})"
  fi
}

run_program_checks() {
  local script="$1"
  echo "Testing ${script} ..."
  # Good inputs: correct decision, exit 0.
  check_run "0.95 verified -> AUTO_ACCEPT" "${script}" 0 "AUTO_ACCEPT (confidence: high)" 0.95 verified
  check_run "0.95 unverified -> REVIEW"    "${script}" 0 "REVIEW (confidence: high)"      0.95 unverified
  check_run "0.30 verified -> REJECT"      "${script}" 0 "REJECT (confidence: low)"       0.30 verified
  check_run "0.90 boundary -> AUTO_ACCEPT" "${script}" 0 "AUTO_ACCEPT"                     0.90 verified
  check_run "0.50 boundary -> REVIEW"      "${script}" 0 "REVIEW (confidence: medium)"    0.50 verified
  # Bad inputs: clear error, exit code 2.
  check_run "non-number score rejected"    "${script}" 2 "is not a number"                hot verified
  check_run "out-of-range score rejected"  "${script}" 2 "out of range"                   1.5 verified
  check_run "bad status rejected"          "${script}" 2 "status must be verified or unverified" 0.8 maybe
  check_run "wrong arg count rejected"     "${script}" 2 "expected 2 arguments"            0.8
}

# --- Reference program: always tested strictly ---
run_program_checks "${ref}"

# --- Import functions and check their return values (main-guard payoff) ---
echo "Testing importability of examples/triage.py ..."
if python3 -c "import sys; sys.path.insert(0, '${lab_dir}/examples'); \
from triage import classify; \
assert classify(0.95, True) == 'AUTO_ACCEPT'; \
assert classify(0.95, False) == 'REVIEW'; \
assert classify(0.30, True) == 'REJECT'"; then
  check "import classify() returns correct decisions" "yes"
else
  check "import classify() returns correct decisions" "no"
fi
if python3 -c "import sys; sys.path.insert(0, '${lab_dir}/examples'); \
from triage import confidence_band; \
assert confidence_band(0.95) == 'high'; \
assert confidence_band(0.50) == 'medium'; \
assert confidence_band(0.10) == 'low'"; then
  check "import confidence_band() returns correct bands" "yes"
else
  check "import confidence_band() returns correct bands" "no"
fi

# --- Learner starter ---
echo "Testing starter/triage.py ..."
if python3 -c "compile(open('${starter}').read(), '${starter}', 'exec')" 2>/dev/null; then
  check "starter is valid Python" "yes"
else
  check "starter is valid Python" "no"
fi

if grep -q 'NotImplementedError' "${starter}"; then
  echo "Note: starter/triage.py still has unfinished exercises — testing structure only."
  grep -q 'def classify' "${starter}" && check "starter defines classify" "yes" || check "starter defines classify" "no"
  grep -q 'def confidence_band' "${starter}" && check "starter defines confidence_band" "yes" || check "starter defines confidence_band" "no"
else
  # Learner finished: hold the starter to the same strict standard.
  run_program_checks "${starter}"
  grep -q '__name__ == "__main__"' "${starter}" && check "starter has the main guard" "yes" || check "starter has the main guard" "no"
fi

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