On Your Own: A Fresh Brief

Compare with yours after you have something working. It’s one reasonable design, not the answer — yours can differ in every line and still be good.

CATEGORIES = {"travel", "meals", "equipment"}
AMOUNT = re.compile(r"\d+(?:\.\d{1,2})?")


@dataclass(frozen=True)
class Claim:
    day: date
    employee: str
    category: str
    cents: int                 # money as whole cents: no float surprises


class ClaimError(ValueError):
    def __init__(self, line_number, reason):
        super().__init__(f"line {line_number}: {reason}")
        self.line_number = line_number
        self.reason = reason


def parse_amount(text):
    """'12.5' -> 1250. Positive, at most two decimal places."""
    if not AMOUNT.fullmatch(text):
        raise ValueError(f"bad amount: {text!r}")
    whole, _, fraction = text.partition(".")
    cents = int(whole) * 100 + int(fraction.ljust(2, "0") or 0)
    if cents == 0:
        raise ValueError(f"bad amount: {text!r}")
    return cents


def parse_claim(line, line_number):
    parts = [part.strip() for part in line.split(",")]
    if len(parts) != 4:
        raise ClaimError(line_number, f"expected 4 fields, got {len(parts)}")
    day_text, employee, category, amount = parts
    try:
        day = date.fromisoformat(day_text)
    except ValueError:
        raise ClaimError(line_number, f"bad date: {day_text!r}") from None
    if category.lower() not in CATEGORIES:
        raise ClaimError(line_number, f"unknown category: {category!r}")
    try:
        cents = parse_amount(amount)
    except ValueError as error:
        raise ClaimError(line_number, str(error)) from None
    return Claim(day, employee, category.lower(), cents)


def read_claims(lines, errors):
    """Yield the good claims; append a ClaimError to errors for each bad line."""
    for number, line in enumerate(lines, start=1):
        if not line.strip():
            continue
        try:
            yield parse_claim(line, number)
        except ClaimError as error:
            errors.append(error)


def totals(claims, key):
    """{key(claim): total cents}, largest first."""
    sums = {}
    for claim in claims:
        sums[key(claim)] = sums.get(key(claim), 0) + claim.cents
    return dict(sorted(sums.items(), key=lambda pair: -pair[1]))


def money(cents):
    return f"{cents // 100}.{cents % 100:02d}"


def report(claims, errors):
    lines = [f"Claims: {len(claims)} accepted, {len(errors)} rejected"]
    for heading, key in [("By employee", lambda c: c.employee),
                         ("By category", lambda c: c.category)]:
        lines.append(f"{heading}:")
        for name, cents in totals(claims, key).items():
            lines.append(f"  {name:<12}{money(cents):>8}")
    lines.append(f"{'Total':<14}{money(sum(c.cents for c in claims)):>8}")
    if errors:
        lines.append("Rejected:")
        lines.extend(f"  {error}" for error in errors)
    return "\n".join(lines)


class TestClaims(unittest.TestCase):
    def test_a_good_line(self):
        self.assertEqual(parse_claim("2026-09-01, Ada, Travel, 42.5", 1),
                         Claim(date(2026, 9, 1), "Ada", "travel", 4250))

    def test_amounts_become_whole_cents(self):
        for text, cents in {"18": 1800, "12.75": 1275, "64.1": 6410, "0.05": 5}.items():
            with self.subTest(text=text):
                self.assertEqual(parse_amount(text), cents)

    def test_each_kind_of_bad_line_is_rejected_with_its_reason(self):
        for line, reason in {
            "2026-09-04, Alan, equipment": "expected 4 fields, got 3",
            "2026-13-01, Grace, travel, 20": "bad date: '2026-13-01'",
            "2026-09-03, Ada, snacks, 4.20": "unknown category: 'snacks'",
            "2026-09-03, Alan, travel, -5.00": "bad amount: '-5.00'",
            "2026-09-05, Ada, travel, 9.999": "bad amount: '9.999'",
            "2026-09-05, Ada, travel, 0": "bad amount: '0'",
        }.items():
            with self.subTest(line=line):
                with self.assertRaises(ClaimError) as caught:
                    parse_claim(line, 7)
                self.assertEqual(caught.exception.reason, reason)

    def test_blank_lines_are_skipped_not_rejected(self):
        errors = []
        self.assertEqual(list(read_claims(["", "   "], errors)), [])
        self.assertEqual(errors, [])

    def test_bad_lines_keep_their_line_numbers(self):
        errors = []
        list(read_claims(["2026-09-01, Ada, travel, 1", "junk"], errors))
        self.assertEqual([e.line_number for e in errors], [2])

    def test_an_empty_file_gives_an_empty_report(self):
        self.assertEqual(report([], []).splitlines()[0], "Claims: 0 accepted, 0 rejected")


errors = []
claims = list(read_claims(CLAIMS.splitlines(), errors))
print(report(claims, errors))

suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestClaims)
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(suite)

Some choices worth comparing with yours:

• Money is whole cents, parsed from the text with integer arithmetic, so it never passes through a float. money() turns it back into text only when it’s shown. (decimal.Decimal is the other good answer.)
• The amount rule is a regex with fullmatch, the Day 2 habit: describe exactly what’s allowed, and everything else is refused — including 9.999, which float() would have accepted without a word.
• totals takes a key function, Day 4’s idea, so “by day” would be one more line in report, not a new function.
• The tests check reasons, not just failures. A test that only asked “did it raise?” would still pass if every bad line got the same useless message.