Free Python Programming Learning Path for Beginners

If not, begin with setup and practice opening the project folder before writing logic.

CSV fields arrive as strings; explicit conversion is needed for arithmetic.

The program should report a clear error and return a nonzero exit code, not invent an empty successful report.

WIKIFREE / THE MAKER'S TERMINAL
Original synthetic case and reference solution. 12 October 2026.

INPUT CONTRACT
Required header: ticket_id,team,minutes,status,note. No additional columns.
IDs must be nonblank and unique. Team: Support, Billing or Operations.
Status: open or closed. Minutes: nonnegative integer; blank is invalid.
Whitespace around IDs, team and status is trimmed. Notes may contain commas
when quoted correctly. Header-only is a valid empty dataset. No header is invalid.
Validate the whole file before printing a success summary. Errors exit with code 2.

RUN
Save the three code/data sections below using their indicated filenames.
python ticket_summary.py sample_tickets.csv
python -m unittest -v test_ticket_summary.py
Use the Python 3 launcher appropriate to your system. Only standard library needed.
Expected sample: 6 tickets, 105 minutes, 3 open. Billing 2/30, Operations 1/35,
Support 3/40 (tickets/minutes). These are synthetic workload data.

BEFORE THE REFERENCE
Build parse_minutes, then summary logic, then CSV reading, then the CLI.
Keep a prediction/observation test log. Do not copy the solution before trying.
Document your actual Python version and the cases you really executed.


===== sample_tickets.csv =====
ticket_id,team,minutes,status,note
T01,Support,15,closed,"Question, then resolved"
T02,Billing,20,open,Awaiting clarification
T03,Support,0,open,No work recorded yet
T04,Operations,35,closed,Setup complete
T05,Billing,10,closed,Invoice explained
T06,Support,25,open,Follow-up needed


===== ticket_summary.py =====
"""WikiFree training reference: validate an entire CSV before printing a summary."""
import argparse
import csv
import sys

TEAMS = {"Support", "Billing", "Operations"}
STATUSES = {"open", "closed"}
REQUIRED = {"ticket_id", "team", "minutes", "status", "note"}


def parse_minutes(value, row_number):
    if value is None or not value.strip():
        raise ValueError("row {}: minutes is required".format(row_number))
    try:
        minutes = int(value)
    except ValueError:
        raise ValueError("row {}: minutes must be an integer".format(row_number))
    if minutes < 0:
        raise ValueError("row {}: minutes cannot be negative".format(row_number))
    return minutes


def read_tickets(stream):
    reader = csv.DictReader(stream)
    if reader.fieldnames is None or set(reader.fieldnames) != REQUIRED:
        raise ValueError("header must contain ticket_id, team, minutes, status and note")
    if len(reader.fieldnames) != len(REQUIRED):
        raise ValueError("header contains duplicate columns")
    rows, seen = [], set()
    for line_number, raw in enumerate(reader, 2):
        if None in raw or any(value is None for value in raw.values()):
            raise ValueError("row {}: wrong number of fields".format(line_number))
        ticket_id = raw["ticket_id"].strip()
        if not ticket_id or ticket_id in seen:
            raise ValueError("row {}: missing or duplicate ticket_id".format(line_number))
        team = raw["team"].strip()
        status = raw["status"].strip()
        if team not in TEAMS:
            raise ValueError("row {}: unknown team {!r}".format(line_number, team))
        if status not in STATUSES:
            raise ValueError("row {}: unknown status {!r}".format(line_number, status))
        minutes = parse_minutes(raw["minutes"], line_number)
        seen.add(ticket_id)
        rows.append({"ticket_id": ticket_id, "team": team, "minutes": minutes,
                     "status": status, "note": raw["note"]})
    return rows


def summarize(rows):
    result = {"tickets": 0, "minutes": 0, "open": 0, "teams": {}}
    for row in rows:
        result["tickets"] += 1
        result["minutes"] += row["minutes"]
        result["open"] += int(row["status"] == "open")
        team = result["teams"].setdefault(row["team"], {"tickets": 0, "minutes": 0})
        team["tickets"] += 1
        team["minutes"] += row["minutes"]
    return result


def format_summary(result):
    lines = ["Tickets: {}".format(result["tickets"]),
             "Total minutes: {}".format(result["minutes"]),
             "Open tickets: {}".format(result["open"])]
    for name, team in sorted(result["teams"].items()):
        lines.append("{}: {} tickets, {} minutes".format(name, team["tickets"], team["minutes"]))
    return "\n".join(lines)


def main(argv=None):
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("input_csv", help="UTF-8 CSV with the documented five-column header")
    args = parser.parse_args(argv)
    try:
        with open(args.input_csv, encoding="utf-8-sig", newline="") as stream:
            rows = read_tickets(stream)
        result = summarize(rows)
    except (OSError, UnicodeError, ValueError, csv.Error) as error:
        print("Error: {}".format(error), file=sys.stderr)
        return 2
    print(format_summary(result))
    return 0


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


===== test_ticket_summary.py =====
import contextlib
import io
import pathlib
import tempfile
import unittest
from ticket_summary import read_tickets, summarize, parse_minutes, main

HEADER = "ticket_id,team,minutes,status,note\n"


class TicketSummaryTests(unittest.TestCase):
    def parse(self, body):
        return read_tickets(io.StringIO(HEADER + body))

    def test_normal_totals_and_quoted_comma(self):
        rows = self.parse('A,Support,15,open,"Question, then follow-up"\nB,Billing,5,closed,Done\nC,Support,0,open,Waiting\n')
        self.assertEqual(summarize(rows), {"tickets": 3, "minutes": 20, "open": 2,
                                          "teams": {"Support": {"tickets": 2, "minutes": 15},
                                                    "Billing": {"tickets": 1, "minutes": 5}}})
        self.assertEqual(rows[0]["note"], "Question, then follow-up")

    def test_zero_is_valid(self):
        self.assertEqual(parse_minutes("0", 2), 0)

    def test_invalid_minutes(self):
        for value in ("-1", "", "2.5", "hello", None):
            with self.subTest(value=value), self.assertRaises(ValueError):
                parse_minutes(value, 2)

    def test_header_only_is_valid_empty_dataset(self):
        self.assertEqual(summarize(self.parse("")), {"tickets": 0, "minutes": 0, "open": 0, "teams": {}})

    def test_missing_header(self):
        with self.assertRaisesRegex(ValueError, "header"):
            read_tickets(io.StringIO(""))

    def test_duplicate_id(self):
        with self.assertRaisesRegex(ValueError, "duplicate"):
            self.parse("A,Support,1,open,x\nA,Support,2,closed,y\n")

    def test_duplicate_header(self):
        with self.assertRaisesRegex(ValueError, "duplicate columns"):
            read_tickets(io.StringIO(HEADER.strip() + ",note\n"))

    def test_unknown_team_and_status(self):
        for row in ("A,Unknown,1,open,x\n", "A,Support,1,maybe,x\n"):
            with self.subTest(row=row), self.assertRaises(ValueError):
                self.parse(row)

    def test_wrong_field_count(self):
        for row in ("A,Support,1,open\n", "A,Support,1,open,x,extra\n"):
            with self.subTest(row=row), self.assertRaisesRegex(ValueError, "fields"):
                self.parse(row)

    def test_missing_file_nonzero_and_no_success_output(self):
        with tempfile.TemporaryDirectory() as folder:
            out, err = io.StringIO(), io.StringIO()
            with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
                code = main([str(pathlib.Path(folder) / "absent.csv")])
            self.assertEqual(code, 2)
            self.assertEqual(out.getvalue(), "")
            self.assertIn("Error:", err.getvalue())

    def test_late_bad_row_does_not_print_partial_success(self):
        with tempfile.TemporaryDirectory() as folder:
            path = pathlib.Path(folder) / "tickets.csv"
            path.write_text(HEADER + "A,Support,10,open,Valid\nB,Support,-1,open,Invalid\n")
            out, err = io.StringIO(), io.StringIO()
            with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
                code = main([str(path)])
            self.assertEqual(code, 2)
            self.assertEqual(out.getvalue(), "")
            self.assertIn("negative", err.getvalue())


if __name__ == "__main__":
    unittest.main()

No. This project is intentionally small enough for csv, argparse and unittest. Learn the input contract before adding dependencies.

Try each stage first. Compare behavior and design afterward; matching the reference character for character is not the goal.