Visualizing attendance helps coaches quickly identify participation trends across the team. By creating a bar chart of team attendance, you can immediately spot which athletes are consistently present and who may need additional support or encouragement. This approach transforms raw attendance data into an accessible visual summary, making it easier to communicate and act on participation insights.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import sys
import types
from unittest.mock import patch
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

class TestTask(unittest.TestCase):
    def setUp(self):
        self.user_code = importlib.import_module("user_code")
        importlib.reload(self.user_code)

    def test_count_sessions_attended(self):
        test_data = [
            {"name": "Sam", "attendance": [True, False, True]},
            {"name": "Taylor", "attendance": [False, False, False]},
            {"name": "Jamie", "attendance": [True, True, True, True]}
        ]
        with patch("matplotlib.pyplot.show"):
            # Patch plt.bar to capture arguments
            with patch("matplotlib.pyplot.bar") as mock_bar:
                self.user_code.plot_team_attendance(test_data)
                args, kwargs = mock_bar.call_args
                names = list(args[0]) if len(args) > 0 else []
                counts = list(args[1]) if len(args) > 1 else []
                _dynamic_test(
                    self,
                    names == ["Sam", "Taylor", "Jamie"],
                    "Bar chart x-axis has correct athlete names.",
                    f"Expected names ['Sam', 'Taylor', 'Jamie'], got {names}",
                )
                _dynamic_test(
                    self,
                    counts == [2, 0, 4],
                    "Bar chart y-axis has correct session counts.",
                    f"Expected counts [2, 0, 4], got {counts}",
                )
    def test_plot_labels_and_show(self):
        test_data = [
            {"name": "A", "attendance": [True]},
            {"name": "B", "attendance": [False]},
        ]
        with (
            patch("matplotlib.pyplot.show") as mock_show,
            patch("matplotlib.pyplot.xlabel") as mock_xlabel,
            patch("matplotlib.pyplot.ylabel") as mock_ylabel,
            patch("matplotlib.pyplot.title") as mock_title,
            patch("matplotlib.pyplot.bar")
        ):
            self.user_code.plot_team_attendance(test_data)
            xlabel_args = mock_xlabel.call_args[0][0] if mock_xlabel.call_args else None
            ylabel_args = mock_ylabel.call_args[0][0] if mock_ylabel.call_args else None
            title_args = mock_title.call_args[0][0] if mock_title.call_args else None
            _dynamic_test(
                self,
                xlabel_args == "Athlete",
                "x-axis is labeled 'Athlete'.",
                f"Expected x-axis label 'Athlete', got {xlabel_args}",
            )
            _dynamic_test(
                self,
                ylabel_args == "Sessions Attended",
                "y-axis is labeled 'Sessions Attended'.",
                f"Expected y-axis label 'Sessions Attended', got {ylabel_args}",
            )
            _dynamic_test(
                self,
                title_args == "Team Attendance",
                "Chart is titled 'Team Attendance'.",
                f"Expected title 'Team Attendance', got {title_args}",
            )
            _dynamic_test(
                self,
                mock_show.called,
                "Chart is displayed with plt.show().",
                "plt.show() was not called to display the chart.",
            )
    def test_handles_empty_attendance(self):
        test_data = [
            {"name": "Chris", "attendance": []},
            {"name": "Jamie", "attendance": []},
        ]
        with patch("matplotlib.pyplot.show") as mock_show:
            with patch("matplotlib.pyplot.bar") as mock_bar:
                self.user_code.plot_team_attendance(test_data)
                args, kwargs = mock_bar.call_args
                names = list(args[0]) if len(args) > 0 else []
                counts = list(args[1]) if len(args) > 1 else []
                _dynamic_test(
                    self,
                    names == ["Chris", "Jamie"],
                    "Handles empty attendance lists and plots names.",
                    f"Expected names ['Chris', 'Jamie'], got {names}",
                )
                _dynamic_test(
                    self,
                    counts == [0, 0],
                    "Handles empty attendance lists and plots zeros.",
                    f"Expected counts [0, 0], got {counts}",
                )
    def test_no_error_on_valid_input(self):
        test_data = [
            {"name": "Alex", "attendance": [True, False, True, True]},
            {"name": "Jordan", "attendance": [True, True, True, False]},
            {"name": "Morgan", "attendance": [False, False, True, True]}
        ]
        try:
            with patch("matplotlib.pyplot.show"):
                self.user_code.plot_team_attendance(test_data)
            _dynamic_test(
                self,
                True,
                "Function runs without error on valid input.",
                "Should not fail.",
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "Should not raise error.",
                f"Function raised exception: {e}",
            )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

A practical Python course designed specifically for coaches, trainers, and sports professionals. Learn how to leverage Python to analyze performance, track progress, and make data-driven decisions to enhance coaching outcomes.

Learn how to use Python to monitor, analyze, and visualize individual athlete progress and performance metrics.

Use Python to analyze and compare team-level data, uncover trends, and support strategic coaching decisions.

Explore how Python can automate repetitive coaching tasks, generate reports, and provide actionable insights.

Challenge: Plot Team Attendance

Solution

Challenge: Plot Team Attendance

Solution