Day 06: Truthiness and branching with text/data

Reference solution (truthiness.py):

def presence(value):
    if value:
        return "present"
    return "missing"
for value in [[], [0], "", " ", 0, "0"]:
    print(repr(value), bool(value), presence(value))

Exact output (Python 3.13 and 3.14):

[] False missing
[0] True present
'' False missing
' ' True present
0 False missing
'0' True present

Explanation: [], "", and 0 are falsy, so the branch reports them as "missing". [0], " ", and "0" are truthy, so the branch reports them as "present". Two rows mislead: whitespace-only text is reported as present although it carries no data, and the number 0 is reported as missing although it is a real value. When the meaning matters, test explicitly (for example text.strip() == "" or value is None) instead of relying on truthiness.

Conversion rule: strip once; empty text is "missing"; text made only of ASCII digits is converted with int(text) and becomes "zero" or "positive"; everything else is "invalid".

Reference implementation (classify.py):

def classify(raw):
    text = raw.strip()
    if text == "":
        return "missing"
    if text.isascii() and text.isdigit():
        number = int(text)
        if number == 0:
            return "zero"
        return "positive"
    return "invalid"
cases = [" 7 ", "", "0", "unknown", "   ", "\t\n", "　7", "007", "00",
         "Zero", "-3", "+7", "3.5", "1_000", "1 2", "７"]
for raw in cases:
    print(f"{raw!r:12} -> {classify(raw)}")

Exact output, which is the complete input → output table (Python 3.13 and 3.14):

' 7 '        -> positive
''           -> missing
'0'          -> zero
'unknown'    -> invalid
'   '        -> missing
'\t\n'       -> missing
'\u30007'    -> positive
'007'        -> positive
'00'         -> zero
'Zero'       -> invalid
'-3'         -> invalid
'+7'         -> invalid
'3.5'        -> invalid
'1_000'      -> invalid
'1 2'        -> invalid
'７'          -> invalid

Why each guard exists: strip() turns ' ' and '\t\n' into empty text, so they are "missing" (plain bool() would call them present), and turns '\u30007' (full-width space plus 7) into '7'. '00' converts to 0, so it is "zero". The isascii() check rejects '７' even though '７'.isdigit() is True and int('７') returns 7. Signs, decimal points, underscores, inner spaces, and words are "invalid" and are never converted to 0.

Complete sequence (bash). Run every step in the same terminal; all commands run inside the disposable repository.

Step 1: create the repository and write your expectations before seeing any proposal.

work=$(mktemp -d)
cd "$work"
git init -q
cat > expected.txt <<'EOF'
' 7 ' -> positive
'' -> missing
'0' -> zero
'unknown' -> invalid
'   ' -> missing
' 0 ' -> zero
EOF

Step 2: commit the buggy baseline and test it.

cat > classify.py <<'EOF'
def classify(raw):
    if not raw:
        return "missing"
    if raw == "0":
        return "zero"
    return "positive"
for raw in [" 7 ", "", "0", "unknown", "   ", " 0 "]:
    print(f"{raw!r} -> {classify(raw)}")
EOF
git add classify.py
git -c user.name="Day06 Learner" -c [email protected] commit -q -m "Add baseline classify"
python3 classify.py > actual.txt
diff expected.txt actual.txt; echo "diff exit: $?"

Output: the baseline mislabels three inputs because it branches on the truthiness of the raw text.

4,6c4,6
< 'unknown' -> invalid
< '   ' -> missing
< ' 0 ' -> zero
---
> 'unknown' -> positive
> '   ' -> positive
> ' 0 ' -> positive
diff exit: 1

Step 3: apply the proposed replacement (here, the Activity 02 reference with the same six inputs) and inspect the diff.

cat > classify.py <<'EOF'
def classify(raw):
    text = raw.strip()
    if text == "":
        return "missing"
    if text.isascii() and text.isdigit():
        number = int(text)
        if number == 0:
            return "zero"
        return "positive"
    return "invalid"
for raw in [" 7 ", "", "0", "unknown", "   ", " 0 "]:
    print(f"{raw!r} -> {classify(raw)}")
EOF
git diff
git diff --stat

Output:

diff --git a/classify.py b/classify.py
index 35040ac..bc9c7bf 100644
--- a/classify.py
+++ b/classify.py
@@ -1,8 +1,12 @@
 def classify(raw):
-    if not raw:
+    text = raw.strip()
+    if text == "":
         return "missing"
-    if raw == "0":
-        return "zero"
-    return "positive"
+    if text.isascii() and text.isdigit():
+        number = int(text)
+        if number == 0:
+            return "zero"
+        return "positive"
+    return "invalid"
 for raw in [" 7 ", "", "0", "unknown", "   ", " 0 "]:
     print(f"{raw!r} -> {classify(raw)}")
 classify.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

Step 4: verify before staging.

python3 classify.py > actual.txt
diff expected.txt actual.txt; echo "diff exit: $?"
git diff --check; echo "check exit: $?"
git status --short

Output:

diff exit: 0
check exit: 0
 M classify.py
?? actual.txt
?? expected.txt

Step 5: stage and commit only the reviewed file.

git add classify.py
git diff --cached --name-only
git -c user.name="Day06 Learner" -c [email protected] commit -q -m "Classify by normalized text"
git log -1 --format=%s
git diff --stat HEAD~1 HEAD
git status --short

Output:

classify.py
Classify by normalized text
 classify.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)
?? actual.txt
?? expected.txt

Verified with Git 2.56 and Python 3.13/3.14. git -c user.name=... -c user.email=... sets the author for that single commit without changing your Git configuration. Keep as evidence: expected.txt, both diff results, the clean git diff --check, and the one-file commit. Label the agent review as agent-assisted; it does not prove independent mastery.

Complete worked solution (bash; the Python file is created and committed inside a new disposable repository):

work=$(mktemp -d)
cd "$work"
git init -q
cat > quantity.py <<'EOF'
def quantity_message(raw):
    text = raw.strip()
    if text == "":
        return "missing: enter a whole number"
    if text.isascii() and text.isdigit():
        number = int(text)
        if number == 0:
            return "zero: nothing to order"
        return f"ok: {number}"
    return f"invalid: {text!r} is not a whole number"
cases = {
    "": "missing: enter a whole number",
    "0": "zero: nothing to order",
    "unknown": "invalid: 'unknown' is not a whole number",
    " 12 ": "ok: 12",
}
for raw, expected in cases.items():
    actual = quantity_message(raw)
    assert actual == expected, (raw, actual, expected)
    print(f"{raw!r} -> {actual}")
print("all 4 cases passed")
EOF
python3 quantity.py
git add quantity.py
git diff --cached --check && echo "diff check clean"
git diff --cached --name-only
git -c user.name="Day06 Learner" -c [email protected] commit -q -m "Add quantity_message with edge-case checks"
git log -1 --format=%s
git status --short; echo "status exit: $?"

Exact output (Python 3.13/3.14, Git 2.56):

'' -> missing: enter a whole number
'0' -> zero: nothing to order
'unknown' -> invalid: 'unknown' is not a whole number
' 12 ' -> ok: 12
all 4 cases passed
diff check clean
quantity.py
Add quantity_message with edge-case checks
status exit: 0

Worked explanation of a surprising result: bool("0") is True, so a branch written as if raw: treats the text "0" as present, and bool(" ") is also True, so whitespace-only text looks present too. The function therefore never branches on raw truthiness: it strips first and compares text == "" explicitly. A second surprise: int(" 7 ") returns 7 and int("７") returns 7, because int() itself strips whitespace and accepts non-ASCII digits; the isascii() and isdigit() check keeps the accepted inputs exactly as the contract states.

Safe-diff record: git diff --cached --name-only lists only quantity.py, git diff --cached --check is clean, and git status --short prints nothing after the commit.